JS.Map.Primitive.Internal

data Map t0 t1

Instances

• (Key k) => Functor (Map k)
• (Key k) => FunctorWithIndex k (Map k)
• (Key k) => Foldable (Map k)
• (Key k) => FoldableWithIndex k (Map k)
• (Key k) => Traversable (Map k)
• (Key k) => TraversableWithIndex k (Map k)
• (Key k, Eq v) => Eq (Map k v)
• (Key k) => Eq1 (Map k)
• (Key k, Ord v) => Ord (Map k v)
• (Key k, Show v) => Show (Map k v)
• (Key k, Semigroup v) => Semigroup (Map k v)
• (Key k, Semigroup v) => Monoid (Map k v)

data STMap :: Region -> Type -> Type -> Typedata STMap t0 t1 t2

A reference to a mutable Map

The first type parameter represents the memory region which the map belongs to. The second type parameter defines the type of elements of the mutable map.

The runtime representation of a value of type STMap r k v is the same as that of Map k v, except that mutation is allowed.

_copyST :: forall a b r. a -> ST r b

thaw :: forall r k v. Map k v -> ST r (STMap r k v)

Convert an immutable Map into a mutable Map

freeze :: forall r k v. STMap r k v -> ST r (Map k v)

Convert a mutable Map into an immutable Map

run :: forall k v. (forall r. ST r (STMap r k v)) -> Map k v

Freeze a mutable Map, creating an immutable Map. Use this function as you would use Control.Monad.ST.run (from the purescript-st package) to freeze a mutable reference.

The rank-2 type prevents the Map from escaping the scope of run.

mutate :: forall a k v. Key k => (forall r. STMap r k v -> ST r a) -> Map k v -> Map k v

_fmapMap :: forall k v v'. Fn2 (Map k v) (v -> v') (Map k v')

_foldM :: forall k v m z. (m -> (z -> m) -> m) -> (z -> k -> v -> m) -> m -> Map k v -> m

fold :: forall k v z. Key k => (z -> k -> v -> z) -> z -> Map k v -> z

Fold the keys and values of an object

foldMap :: forall k v m. Key k => Monoid m => (k -> v -> m) -> Map k v -> m

Fold the keys and values of an object, accumulating values using some Monoid.

foldM :: forall k v m z. Key k => Monad m => (z -> k -> v -> m z) -> z -> Map k v -> m z

Fold the keys and values of an object, accumulating values and effects in some Monad.

_foldSCMap :: forall k v z. Fn4 (Map k v) z (z -> k -> v -> Maybe z) (forall b. b -> Maybe b -> b) z

foldMaybe :: forall k v z. Key k => (z -> k -> v -> Maybe z) -> z -> Map k v -> z

Fold the keys and values of a map.

This function allows the folding function to terminate the fold early, using Maybe.

all :: forall k v. Key k => (k -> v -> Boolean) -> Map k v -> Boolean

Test whether all key/value pairs in a Map satisfy a predicate.

_all :: forall k v. (k -> v -> Boolean) -> Map k v -> Boolean

toAscArray :: forall k v. Key k => Map k v -> Array (Tuple k v)

empty :: forall k v. Map k v

An empty map

isSubmap :: forall k v. Key k => Eq v => Map k v -> Map k v -> Boolean

Test whether one map contains all of the keys and values contained in another map

isEmpty :: forall k v. Key k => Map k v -> Boolean

Test whether a map is empty

size :: forall k v. Map k v -> Int

Calculate the number of key/value pairs in a map

singleton :: forall k v. Key k => k -> v -> Map k v

Create an Map a with one key/value pair

_lookup :: forall k v z. Fn4 z (v -> z) k (Map k v) z

lookup :: forall k v. Key k => k -> Map k v -> Maybe v

Lookup the value for a key in a map

member :: forall k v. Key k => k -> Map k v -> Boolean

Test whether a key appears in a map

insert :: forall k v. Key k => k -> v -> Map k v -> Map k v

Insert or replace a key/value pair in a map

delete :: forall k v. Key k => k -> Map k v -> Map k v

Delete a key and value from a map

pop :: forall k v. Key k => k -> Map k v -> Maybe (Tuple v (Map k v))

Delete a key and value from a map, returning the value as well as the subsequent map

alter :: forall k v. Key k => (Maybe v -> Maybe v) -> k -> Map k v -> Map k v

Insert, remove or update a value for a key in a map

update :: forall k v. Key k => (v -> Maybe v) -> k -> Map k v -> Map k v

Remove or update a value for a key in a map

fromFoldable :: forall f k v. Key k => Foldable f => f (Tuple k v) -> Map k v

Create an Map k v from a foldable collection of key/value pairs

fromFoldableWithIndex :: forall f k v. Key k => FoldableWithIndex k (f k) => f k v -> Map k v

Create an Map k v from a k-indexed foldable collection

_lookupST :: forall k v r z. STFn4 z (v -> z) k (STMap r k v) r z

fromFoldableWith :: forall f k v. Key k => Foldable f => (v -> v -> v) -> f (Tuple k v) -> Map k v

Create an Map k v from a foldable collection of key/value pairs, using the specified function to combine values for duplicate keys.

toArrayWithKey :: forall k v a. (k -> v -> a) -> Map k v -> Array a

toUnfoldable :: forall f k v. Key k => Unfoldable f => Map k v -> f (Tuple k v)

Unfolds a map into a list of key/value pairs

toAscUnfoldable :: forall f k v. Key k => Unfoldable f => Map k v -> f (Tuple k v)

Unfolds a map into a list of key/value pairs which is guaranteed to be sorted by key

toArray :: forall k v. Key k => Map k v -> Array (Tuple k v)

keys :: forall k v. Map k v -> Array k

Get an array of the keys in a map

values :: forall k v. Map k v -> Array v

Get a list of the values in a map

union :: forall k v. Key k => Map k v -> Map k v -> Map k v

Compute the union of two maps, preferring the first map in the case of duplicate keys.

unionWith :: forall k v. Key k => (v -> v -> v) -> Map k v -> Map k v -> Map k v

Compute the union of two maps, using the specified function to combine values for duplicate keys.

unions :: forall f k v. Key k => Foldable f => f (Map k v) -> Map k v

Compute the union of a collection of maps

_mapWithKey :: forall k v v'. Fn2 (Map k v) (k -> v -> v') (Map k v')

mapWithKey :: forall k v v'. Key k => (k -> v -> v') -> Map k v -> Map k v'

Apply a function of two arguments to each key/value pair, producing a new map

filterWithKey :: forall k v. Key k => (k -> v -> Boolean) -> Map k v -> Map k v

Filter out those key/value pairs of a map for which a predicate fails to hold.

filterKeys :: forall k. Key k => (k -> Boolean) -> (Map k) ~> (Map k)

Filter out those key/value pairs of a map for which a predicate on the key fails to hold.

filter :: forall k v. Key k => (v -> Boolean) -> Map k v -> Map k v

Filter out those key/value pairs of a map for which a predicate on the value fails to hold.

new :: forall r k v. ST r (STMap r k v)

Create a new, empty mutable map

peek :: forall r k v. Key k => k -> STMap r k v -> ST r (Maybe v)

Get the value for a key in a mutable map

peekImpl :: forall r m k v. STFn4 m k (v -> Maybe v) (Maybe v) r v

poke :: forall r k v. Key k => k -> v -> STMap r k v -> ST r (STMap r k v)

Update the value for a key in a mutable map

poke_ :: forall r k v. Key k => k -> v -> STMap r k v -> ST r Unit

pokeImpl :: forall r k v m. STFn3 m k v r Unit

deleteST :: forall r k v. Key k => k -> STMap r k v -> ST r (STMap r k v)

delete_ :: forall r k v. Key k => k -> STMap r k v -> ST r Unit

Remove a key and the corresponding value from a mutable map

deleteImpl :: forall r k m. STFn2 m k r Unit