Control.Effect.Map

The map effect for modeling a mutable collection of key-value pairs.

Lazy and strict interpretations of the effect are available here: Control.Effect.Map.Lazy and Control.Effect.Map.Strict.

Tagged Map Effect

class Monad m => Map' tag k v m | tag m -> k v where

An effect that adds a mutable collection of key-value pairs to a given computation.

Methods

clear' :: m ()

Deletes all key-value pairs from the map.

lookup' :: k -> m (Maybe v)

Searches for a value that corresponds to a given key. Returns Nothing if the key cannot be found.

update' :: k -> Maybe v -> m ()

Updates the value that corresponds to a given key. Passing Nothing as the updated value removes the key-value pair from the map.

Instances

Handle (Map' tag k2 v) t m => Map' (tag :: k1) k2 v (EachVia (Map' tag k2 v ': effs) t m)

Defined in Control.Effect.Map

Methods

clear' :: EachVia (Map' tag k2 v ': effs) t m ()

lookup' :: k2 -> EachVia (Map' tag k2 v ': effs) t m (Maybe v)

update' :: k2 -> Maybe v -> EachVia (Map' tag k2 v ': effs) t m ()

Find (Map' tag k2 v) effs t m => Map' (tag :: k1) k2 v (EachVia (other ': effs) t m)

Defined in Control.Effect.Map

Methods

clear' :: EachVia (other ': effs) t m ()

lookup' :: k2 -> EachVia (other ': effs) t m (Maybe v)

update' :: k2 -> Maybe v -> EachVia (other ': effs) t m ()

Lift (Map' tag k2 v) t m => Map' (tag :: k1) k2 v (EachVia ('[] :: [Effect]) t m)

Defined in Control.Effect.Map

Methods

clear' :: EachVia '[] t m ()

lookup' :: k2 -> EachVia '[] t m (Maybe v)

update' :: k2 -> Maybe v -> EachVia '[] t m ()

(Monad m, Ord k2) => Map' (tag :: k1) k2 v (LazyMap k2 v m)

Defined in Control.Effect.Map.Lazy

Methods

clear' :: LazyMap k2 v m ()

lookup' :: k2 -> LazyMap k2 v m (Maybe v)

update' :: k2 -> Maybe v -> LazyMap k2 v m ()

(Monad m, Ord k2) => Map' (tag :: k1) k2 v (StrictMap k2 v m)

Defined in Control.Effect.Map.Strict

Methods

clear' :: StrictMap k2 v m ()

lookup' :: k2 -> StrictMap k2 v m (Maybe v)

update' :: k2 -> Maybe v -> StrictMap k2 v m ()

Map' new k3 v m => Map' (tag :: k2) k3 v (Tagger tag new m)

Defined in Control.Effect.Map

Methods

clear' :: Tagger tag new m ()

lookup' :: k3 -> Tagger tag new m (Maybe v)

update' :: k3 -> Maybe v -> Tagger tag new m ()

Untagged Map Effect

If you don't require disambiguation of multiple map effects (i.e., you only have one map effect in your monadic context), it is recommended to always use the untagged map effect.

type Map k v = Map' G k v

clear :: Map k v m => m ()

lookup :: Map k v m => k -> m (Maybe v)

update :: Map k v m => k -> Maybe v -> m ()

Convenience Functions

If you don't require disambiguation of multiple map effects (i.e., you only have one map effect in your monadic context), it is recommended to always use the untagged functions.

delete' :: forall tag k v m. Map' tag k v m => k -> m ()

Deletes a key and its corresponding value from the map.

delete :: Map k v m => k -> m ()

The untagged version of delete'.

exists' :: forall tag k v m. Map' tag k v m => k -> m Bool

Checks if the map contains a given key.

exists :: Map k v m => k -> m Bool

The untagged version of exists'.

insert' :: forall tag k v m. Map' tag k v m => k -> v -> m ()

Inserts a new key-value pair into the map. If the key is already present in the map, the associated value is replaced with the new value.

insert :: Map k v m => k -> v -> m ()

The untagged version of insert'.

modify'

Arguments

:: forall tag k v m. Map' tag k v m

=> v

The default value that is assumed if the key is missing.

-> (v -> v)

The function for updating the value. This function is also applied to the default value if the key is missing.

-> k

The key whose corresponding value is updated.

-> m ()

The operation produces no value.

Updates the value that corresponds to a given key. If the key cannot be found, a corresponding default value is assumed.

modify :: Map k v m => v -> (v -> v) -> k -> m ()

The untagged version of modify'.

Tagging and Untagging

Conversion functions between the tagged and untagged map effect, usually used in combination with type applications, like:

    tagMap' @"newTag" program
    retagMap' @"oldTag" @"newTag" program
    untagMap' @"erasedTag" program

tagMap' :: forall new k v m a. Via (Map' G k v) (Tagger G new) m a -> m a

retagMap' :: forall tag new k v m a. Via (Map' tag k v) (Tagger tag new) m a -> m a

untagMap' :: forall tag k v m a. Via (Map' tag k v) (Tagger tag G) m a -> m a