SDP.MapM

SDP.MapM provides MapM - class of mutable associative arrays.

Mutable maps

class Monad m => MapM m map key e | map -> m, map -> key, map -> e where

MapM is class of mutable associative arrays.

Minimal complete definition

newMap', overwrite, ((>!) | (!?>)), kfoldrM, kfoldlM

Methods

newMap :: [(key, e)] -> m map

Create new mutable map from list of (key, element) associations.

newMap' :: e -> [(key, e)] -> m map

Create new mutable map from list of (key, element) associations.

getAssocs :: map -> m [(key, e)]

getAssocs is version of assocs for mutable maps.

default getAssocs :: LinearM m map e => map -> m [(key, e)]

(>!) :: map -> key -> m e infixl 5

(>!) is unsafe monadic reader.

(!>) :: map -> key -> m e infixl 5

(!>) is well-safe monadic reader.

default (!>) :: BorderedM m map key => map -> key -> m e

(!?>) :: map -> key -> m (Maybe e) infixl 5

(!?>) is completely safe monadic reader.

updateM :: map -> (key -> e -> e) -> m map

Update elements by mapping with indices.

overwrite :: map -> [(key, e)] -> m map

This function designed to overwrite large enough fragments of the structure (unlike writeM and writeM')

In addition to write operations, overwrite can move and clean, optimize data presentation, etc. of a particular structure. Since the reference to the original structure may not be the same as reference to the result (which implementation is undesirable, but acceptable), the original reference (argument) shouldn't be used after overwrite.

All standard sdp structures support safe in-place overwrite.

If the structure uses unmanaged memory, then all unused fragments in the resulting structure must be deallocated, regardless of reachability by original reference (argument).

Please note that overwrite require a list of associations with indices in the current structure bounds and ignore any other, therefore:

fromAssocs bnds ascs /= (fromAssocs bnds ascs >>= flip overwrite ascs)

memberM' :: map -> key -> m Bool

Checks if key in map.

default memberM' :: BorderedM m map key => map -> key -> m Bool

getKeys :: map -> m [key]

Returns list of map keys.

default getKeys :: BorderedM m map key => map -> m [key]

(.?) :: (e -> Bool) -> map -> m (Maybe key)

(.?) is monadic version of (.$).

(*?) :: (e -> Bool) -> map -> m [key]

(*?) is monadic version of (*$).

kfoldrM :: (key -> e -> acc -> m acc) -> acc -> map -> m acc

kfoldrM is right monadic fold with key.

kfoldlM :: (key -> acc -> e -> m acc) -> acc -> map -> m acc

kfoldlM is left monadic fold with key.

kfoldrM' :: (key -> e -> acc -> m acc) -> acc -> map -> m acc

kfoldrM' is strict version of kfoldrM.

kfoldlM' :: (key -> acc -> e -> m acc) -> acc -> map -> m acc

kfoldlM' is strict version of kfoldlM.

Instances

MapM STM (TArray# e) Int e

Defined in SDP.Prim.TArray

Methods

newMap :: [(Int, e)] -> STM (TArray# e)

newMap' :: e -> [(Int, e)] -> STM (TArray# e)

getAssocs :: TArray# e -> STM [(Int, e)]

(>!) :: TArray# e -> Int -> STM e

(!>) :: TArray# e -> Int -> STM e

(!?>) :: TArray# e -> Int -> STM (Maybe e)

updateM :: TArray# e -> (Int -> e -> e) -> STM (TArray# e)

overwrite :: TArray# e -> [(Int, e)] -> STM (TArray# e)

memberM' :: TArray# e -> Int -> STM Bool

getKeys :: TArray# e -> STM [Int]

(.?) :: (e -> Bool) -> TArray# e -> STM (Maybe Int)

(*?) :: (e -> Bool) -> TArray# e -> STM [Int]

kfoldrM :: (Int -> e -> acc -> STM acc) -> acc -> TArray# e -> STM acc

kfoldlM :: (Int -> acc -> e -> STM acc) -> acc -> TArray# e -> STM acc

kfoldrM' :: (Int -> e -> acc -> STM acc) -> acc -> TArray# e -> STM acc

kfoldlM' :: (Int -> acc -> e -> STM acc) -> acc -> TArray# e -> STM acc

(MonadIO io, Unboxed e) => MapM io (MIOBytes# io e) Int e

Defined in SDP.Prim.SBytes

Methods

newMap :: [(Int, e)] -> io (MIOBytes# io e)

newMap' :: e -> [(Int, e)] -> io (MIOBytes# io e)

getAssocs :: MIOBytes# io e -> io [(Int, e)]

(>!) :: MIOBytes# io e -> Int -> io e

(!>) :: MIOBytes# io e -> Int -> io e

(!?>) :: MIOBytes# io e -> Int -> io (Maybe e)

updateM :: MIOBytes# io e -> (Int -> e -> e) -> io (MIOBytes# io e)

overwrite :: MIOBytes# io e -> [(Int, e)] -> io (MIOBytes# io e)

memberM' :: MIOBytes# io e -> Int -> io Bool

getKeys :: MIOBytes# io e -> io [Int]

(.?) :: (e -> Bool) -> MIOBytes# io e -> io (Maybe Int)

(*?) :: (e -> Bool) -> MIOBytes# io e -> io [Int]

kfoldrM :: (Int -> e -> acc -> io acc) -> acc -> MIOBytes# io e -> io acc

kfoldlM :: (Int -> acc -> e -> io acc) -> acc -> MIOBytes# io e -> io acc

kfoldrM' :: (Int -> e -> acc -> io acc) -> acc -> MIOBytes# io e -> io acc

kfoldlM' :: (Int -> acc -> e -> io acc) -> acc -> MIOBytes# io e -> io acc

MonadIO io => MapM io (MIOArray# io e) Int e

Defined in SDP.Prim.SArray

Methods

newMap :: [(Int, e)] -> io (MIOArray# io e)

newMap' :: e -> [(Int, e)] -> io (MIOArray# io e)

getAssocs :: MIOArray# io e -> io [(Int, e)]

(>!) :: MIOArray# io e -> Int -> io e

(!>) :: MIOArray# io e -> Int -> io e

(!?>) :: MIOArray# io e -> Int -> io (Maybe e)

updateM :: MIOArray# io e -> (Int -> e -> e) -> io (MIOArray# io e)

overwrite :: MIOArray# io e -> [(Int, e)] -> io (MIOArray# io e)

memberM' :: MIOArray# io e -> Int -> io Bool

getKeys :: MIOArray# io e -> io [Int]

(.?) :: (e -> Bool) -> MIOArray# io e -> io (Maybe Int)

(*?) :: (e -> Bool) -> MIOArray# io e -> io [Int]

kfoldrM :: (Int -> e -> acc -> io acc) -> acc -> MIOArray# io e -> io acc

kfoldlM :: (Int -> acc -> e -> io acc) -> acc -> MIOArray# io e -> io acc

kfoldrM' :: (Int -> e -> acc -> io acc) -> acc -> MIOArray# io e -> io acc

kfoldlM' :: (Int -> acc -> e -> io acc) -> acc -> MIOArray# io e -> io acc

(SplitM1 m rep e, MapM1 m rep Int e, BorderedM1 m rep Int e) => MapM m (AnyChunks rep e) Int e

Defined in SDP.Templates.AnyChunks

Methods

newMap :: [(Int, e)] -> m (AnyChunks rep e)

newMap' :: e -> [(Int, e)] -> m (AnyChunks rep e)

getAssocs :: AnyChunks rep e -> m [(Int, e)]

(>!) :: AnyChunks rep e -> Int -> m e

(!>) :: AnyChunks rep e -> Int -> m e

(!?>) :: AnyChunks rep e -> Int -> m (Maybe e)

updateM :: AnyChunks rep e -> (Int -> e -> e) -> m (AnyChunks rep e)

overwrite :: AnyChunks rep e -> [(Int, e)] -> m (AnyChunks rep e)

memberM' :: AnyChunks rep e -> Int -> m Bool

getKeys :: AnyChunks rep e -> m [Int]

(.?) :: (e -> Bool) -> AnyChunks rep e -> m (Maybe Int)

(*?) :: (e -> Bool) -> AnyChunks rep e -> m [Int]

kfoldrM :: (Int -> e -> acc -> m acc) -> acc -> AnyChunks rep e -> m acc

kfoldlM :: (Int -> acc -> e -> m acc) -> acc -> AnyChunks rep e -> m acc

kfoldrM' :: (Int -> e -> acc -> m acc) -> acc -> AnyChunks rep e -> m acc

kfoldlM' :: (Int -> acc -> e -> m acc) -> acc -> AnyChunks rep e -> m acc

(Index i, MapM1 m rep Int e, LinearM1 m rep e, BorderedM1 m rep Int e) => MapM m (AnyBorder rep i e) i e

Defined in SDP.Templates.AnyBorder

Methods

newMap :: [(i, e)] -> m (AnyBorder rep i e)

newMap' :: e -> [(i, e)] -> m (AnyBorder rep i e)

getAssocs :: AnyBorder rep i e -> m [(i, e)]

(>!) :: AnyBorder rep i e -> i -> m e

(!>) :: AnyBorder rep i e -> i -> m e

(!?>) :: AnyBorder rep i e -> i -> m (Maybe e)

updateM :: AnyBorder rep i e -> (i -> e -> e) -> m (AnyBorder rep i e)

overwrite :: AnyBorder rep i e -> [(i, e)] -> m (AnyBorder rep i e)

memberM' :: AnyBorder rep i e -> i -> m Bool

getKeys :: AnyBorder rep i e -> m [i]

(.?) :: (e -> Bool) -> AnyBorder rep i e -> m (Maybe i)

(*?) :: (e -> Bool) -> AnyBorder rep i e -> m [i]

kfoldrM :: (i -> e -> acc -> m acc) -> acc -> AnyBorder rep i e -> m acc

kfoldlM :: (i -> acc -> e -> m acc) -> acc -> AnyBorder rep i e -> m acc

kfoldrM' :: (i -> e -> acc -> m acc) -> acc -> AnyBorder rep i e -> m acc

kfoldlM' :: (i -> acc -> e -> m acc) -> acc -> AnyBorder rep i e -> m acc

Unboxed e => MapM (ST s) (STBytes# s e) Int e

Defined in SDP.Prim.SBytes

Methods

newMap :: [(Int, e)] -> ST s (STBytes# s e)

newMap' :: e -> [(Int, e)] -> ST s (STBytes# s e)

getAssocs :: STBytes# s e -> ST s [(Int, e)]

(>!) :: STBytes# s e -> Int -> ST s e

(!>) :: STBytes# s e -> Int -> ST s e

(!?>) :: STBytes# s e -> Int -> ST s (Maybe e)

updateM :: STBytes# s e -> (Int -> e -> e) -> ST s (STBytes# s e)

overwrite :: STBytes# s e -> [(Int, e)] -> ST s (STBytes# s e)

memberM' :: STBytes# s e -> Int -> ST s Bool

getKeys :: STBytes# s e -> ST s [Int]

(.?) :: (e -> Bool) -> STBytes# s e -> ST s (Maybe Int)

(*?) :: (e -> Bool) -> STBytes# s e -> ST s [Int]

kfoldrM :: (Int -> e -> acc -> ST s acc) -> acc -> STBytes# s e -> ST s acc

kfoldlM :: (Int -> acc -> e -> ST s acc) -> acc -> STBytes# s e -> ST s acc

kfoldrM' :: (Int -> e -> acc -> ST s acc) -> acc -> STBytes# s e -> ST s acc

kfoldlM' :: (Int -> acc -> e -> ST s acc) -> acc -> STBytes# s e -> ST s acc

MapM (ST s) (STArray# s e) Int e

Defined in SDP.Prim.SArray

Methods

newMap :: [(Int, e)] -> ST s (STArray# s e)

newMap' :: e -> [(Int, e)] -> ST s (STArray# s e)

getAssocs :: STArray# s e -> ST s [(Int, e)]

(>!) :: STArray# s e -> Int -> ST s e

(!>) :: STArray# s e -> Int -> ST s e

(!?>) :: STArray# s e -> Int -> ST s (Maybe e)

updateM :: STArray# s e -> (Int -> e -> e) -> ST s (STArray# s e)

overwrite :: STArray# s e -> [(Int, e)] -> ST s (STArray# s e)

memberM' :: STArray# s e -> Int -> ST s Bool

getKeys :: STArray# s e -> ST s [Int]

(.?) :: (e -> Bool) -> STArray# s e -> ST s (Maybe Int)

(*?) :: (e -> Bool) -> STArray# s e -> ST s [Int]

kfoldrM :: (Int -> e -> acc -> ST s acc) -> acc -> STArray# s e -> ST s acc

kfoldlM :: (Int -> acc -> e -> ST s acc) -> acc -> STArray# s e -> ST s acc

kfoldrM' :: (Int -> e -> acc -> ST s acc) -> acc -> STArray# s e -> ST s acc

kfoldlM' :: (Int -> acc -> e -> ST s acc) -> acc -> STArray# s e -> ST s acc

type MapM1 m map key e = MapM m (map e) key e

Rank (* -> *) MapM.

type MapM2 m map key e = MapM m (map key e) key e

Rank (* -> * -> *) MapM.