Hoogle Search

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

JTMap :: JType -> JType

jmacro Language.Javascript.JMacro.Types

No documentation available.
theMap :: Map ph k v -> Map k v

justified-containers Data.Map.Justified

Get the underlying Data.Map Map out of a Map.

jmacro	Language.Javascript.JMacro.Types

withMap :: Map k v -> (forall ph . () => Map ph k v -> t) -> t

justified-containers	Data.Map.Justified

Evaluate an expression using justified key lookups into the given map.

import qualified Data.Map as M

withMap (M.fromList [(1,"A"), (2,"B")]) $ \m -> do

-- prints "Found Key 1 with value A"
case member 1 m of
Nothing -> putStrLn "Missing key 1."
Just k  -> putStrLn ("Found " ++ show k ++ " with value " ++ lookup k m)

-- prints "Missing key 3."
case member 3 m of
Nothing -> putStrLn "Missing key 3."
Just k  -> putStrLn ("Found " ++ show k ++ " with value " ++ lookup k m)

withRecMap :: (Ord k, Traversable f, Representational f) => Map k (f k) -> (forall ph . () => Map ph k (f (Key ph k)) -> t) -> Either [MissingReference k f] t

justified-containers Data.Map.Justified

Evaluate an expression using justified key lookups into the given map, when the values can contain references back to keys in the map. Each referenced key is checked to ensure that it can be found in the map. If all referenced keys are found, they are augmented with evidence and the given function is applied. If some referenced keys are missing, information about the missing references is generated instead.
```
import qualified Data.Map as M

data Cell ptr = Nil | Cons ptr ptr deriving (Functor, Foldable, Traversable)

memory1 = M.fromList [(1, Cons 2 1), (2, Nil)]
withRecMap memory1 (const ()) -- Right ()

memory2 = M.fromList [(1, Cons 2 3), (2, Nil)]
withRecMap memory2 (const ()) -- Left [(1, Cons (2,Present) (3,Missing))]
```
See example5 for more usage examples.
data KdMap a p v

kdt Data.KdMap.Dynamic

A dynamic k-d tree structure that stores points of type p with axis values of type a. Additionally, each point is associated with a value of type v.
data KdMap a p v

kdt Data.KdMap.Static

A k-d tree structure that stores points of type p with axis values of type a. Additionally, each point is associated with a value of type v.
withMappedConfig :: (cfg -> cfg') -> KeterM cfg' a -> KeterM cfg a

keter Keter.Context

No documentation available.
module Keter.LabelMap

No documentation available.
data LabelMap a

keter Keter.LabelMap

A data structure for storing a hierarchical set of domain labels from TLD down, supporting wildcards. Data structure is mutually recursive with LabelEntry, and each level of the tree supports a static assignment for a hostname such as:
```
example.com
```
Or a wildcard assignment for a hostname such as:
```
*.example.com
```
Or a wildcard assignment with a set of teptions, for example:
```
*.example.com
admin.example.com
```
And lastly, empty labels are supported so that, of course, an assignment for example.com does not necessarily have any subdomains available. As an example suppose we have the following assigned domains:
```
example.com
foo.example.com
*.bar.example.com
*.qux.example.com
baz.qux.example.com
```
This will resolve to the following value, with some loose pseudocode notation.
```
Static (map)
'com' -> Unassigned Static (map)
'example' -> Assigned a (map)
'foo'  -> Assigned a EmptyLabelMap
'bar'  -> Unassigned (Wildcard (Assigned a EmptyLabelMap)
'qux'  -> Unassigned (WildcardExcept (Assigned a (map)))
'baz' -> Assigned a EmptyLabelMap
```
Note that the hostname "bar.example.com" is unassigned, only the wildcard was set.
keyCodeMap :: IntMap Key

keycode Web.KeyCode

An map of known KeyCodes to Keys. Since: 0.1

kdt	Data.KdMap.Dynamic

kdt	Data.KdMap.Static

keter	Keter.Context

keter	Keter.LabelMap

keycode	Web.KeyCode

Page 1187 of many | Previous | Next