SDP.IndexedM

SDP.IndexedM provides IndexedM and Thaw classes.

Exports

module SDP.LinearM

module SDP.Indexed

module SDP.MapM

IndexedM

class (LinearM m v e, BorderedM m v i, MapM m v i e) => IndexedM m v i e where

Class for work with mutable indexed structures.

Minimal complete definition

fromIndexed', fromIndexedM

Methods

fromAssocs :: (i, i) -> [(i, e)] -> m v

fromAssocs bnds ascs creates new structure from list of associations, without default element. Note that bnds is ascs bounds and may not match with the result bounds (not always possible).

fromAssocs' :: (i, i) -> e -> [(i, e)] -> m v

fromAssocs' bnds defvalue ascs creates new structure from list of associations, with default element. Note that bnds is ascs bounds and may not match with the result bounds (not always possible).

writeM' :: v -> i -> e -> m ()

writeM map key e writes element e to key position safely (if key is out of map range, do nothing). The writeM function is intended to overwrite only existing values, so its behavior is identical for structures with both static and dynamic boundaries.

swapM' :: v -> i -> i -> m ()

Just swap two elements.

fromIndexed' :: Indexed v' j e => v' -> m v

fromIndexed' is overloaded version of thaw.

fromIndexedM :: IndexedM m v' j e => v' -> m v

fromIndexed converts one mutable structure to other.

reshaped :: IndexedM m v' j e => (i, i) -> v' -> (i -> j) -> m v

reshaped creates new indexed structure from old with reshaping function.

fromAccum :: (e -> e' -> e) -> v -> [(i, e')] -> m v

fromAccum f es ies create a new structure from es elements selectively updated by function f and ies associations list.

updateM' :: v -> (e -> e) -> i -> m ()

Update element by given function.

Instances

IndexedM STM (TArray# e) Int e

Defined in SDP.Prim.TArray

Methods

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

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

writeM' :: TArray# e -> Int -> e -> STM ()

swapM' :: TArray# e -> Int -> Int -> STM ()

fromIndexed' :: Indexed v' j e => v' -> STM (TArray# e)

fromIndexedM :: IndexedM STM v' j e => v' -> STM (TArray# e)

reshaped :: IndexedM STM v' j e => (Int, Int) -> v' -> (Int -> j) -> STM (TArray# e)

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

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

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

Defined in SDP.Prim.SBytes

Methods

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

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

writeM' :: MIOBytes# io e -> Int -> e -> io ()

swapM' :: MIOBytes# io e -> Int -> Int -> io ()

fromIndexed' :: Indexed v' j e => v' -> io (MIOBytes# io e)

fromIndexedM :: IndexedM io v' j e => v' -> io (MIOBytes# io e)

reshaped :: IndexedM io v' j e => (Int, Int) -> v' -> (Int -> j) -> io (MIOBytes# io e)

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

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

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

Defined in SDP.Prim.SArray

Methods

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

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

writeM' :: MIOArray# io e -> Int -> e -> io ()

swapM' :: MIOArray# io e -> Int -> Int -> io ()

fromIndexed' :: Indexed v' j e => v' -> io (MIOArray# io e)

fromIndexedM :: IndexedM io v' j e => v' -> io (MIOArray# io e)

reshaped :: IndexedM io v' j e => (Int, Int) -> v' -> (Int -> j) -> io (MIOArray# io e)

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

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

(SplitM1 m rep e, IndexedM1 m rep Int e) => IndexedM m (AnyChunks rep e) Int e

Defined in SDP.Templates.AnyChunks

Methods

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

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

writeM' :: AnyChunks rep e -> Int -> e -> m ()

swapM' :: AnyChunks rep e -> Int -> Int -> m ()

fromIndexed' :: Indexed v' j e => v' -> m (AnyChunks rep e)

fromIndexedM :: IndexedM m v' j e => v' -> m (AnyChunks rep e)

reshaped :: IndexedM m v' j e => (Int, Int) -> v' -> (Int -> j) -> m (AnyChunks rep e)

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

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

(Index i, IndexedM1 m rep Int e) => IndexedM m (AnyBorder rep i e) i e

Defined in SDP.Templates.AnyBorder

Methods

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

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

writeM' :: AnyBorder rep i e -> i -> e -> m ()

swapM' :: AnyBorder rep i e -> i -> i -> m ()

fromIndexed' :: Indexed v' j e => v' -> m (AnyBorder rep i e)

fromIndexedM :: IndexedM m v' j e => v' -> m (AnyBorder rep i e)

reshaped :: IndexedM m v' j e => (i, i) -> v' -> (i -> j) -> m (AnyBorder rep i e)

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

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

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

Defined in SDP.Prim.SBytes

Methods

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

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

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

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

fromIndexed' :: Indexed v' j e => v' -> ST s (STBytes# s e)

fromIndexedM :: IndexedM (ST s) v' j e => v' -> ST s (STBytes# s e)

reshaped :: IndexedM (ST s) v' j e => (Int, Int) -> v' -> (Int -> j) -> ST s (STBytes# s e)

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

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

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

Defined in SDP.Prim.SArray

Methods

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

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

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

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

fromIndexed' :: Indexed v' j e => v' -> ST s (STArray# s e)

fromIndexedM :: IndexedM (ST s) v' j e => v' -> ST s (STArray# s e)

reshaped :: IndexedM (ST s) v' j e => (Int, Int) -> v' -> (Int -> j) -> ST s (STArray# s e)

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

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

type IndexedM1 m v i e = IndexedM m (v e) i e

Kind (* -> *) IndexedM.

type IndexedM2 m v i e = IndexedM m (v i e) i e

Kind (* -> * -> *) IndexedM.

Thaw

class Monad m => Thaw m v v' | v' -> m where

Service class of immutable to mutable conversions.

Minimal complete definition

thaw

Methods

thaw :: v -> m v'

thaw is safe way to convert a immutable structure to a mutable. thaw should copy the old structure or ensure that it will not be used after the procedure calling.

unsafeThaw :: v -> m v'

unsafeThaw is unsafe version of thaw. unsafeThaw doesn't guarantee that the structure will be copied or locked. It only guarantees that if the old structure isn't used, no error will occur.

Instances

(Index i, Thaw m imm (rep e), Bordered1 rep Int e) => Thaw m imm (AnyBorder rep i e)

Defined in SDP.Templates.AnyBorder

Methods

thaw :: imm -> m (AnyBorder rep i e)

unsafeThaw :: imm -> m (AnyBorder rep i e)

Thaw STM (SArray# e) (TArray# e)

Defined in SDP.Prim.TArray

Methods

thaw :: SArray# e -> STM (TArray# e)

unsafeThaw :: SArray# e -> STM (TArray# e)

(Storable e, Unboxed e) => Thaw IO (SBytes# e) (Int, Ptr e)

Defined in SDP.Prim.SBytes

Methods

thaw :: SBytes# e -> IO (Int, Ptr e)

unsafeThaw :: SBytes# e -> IO (Int, Ptr e)

Storable e => Thaw IO (SArray# e) (Int, Ptr e)

Defined in SDP.Prim.SArray

Methods

thaw :: SArray# e -> IO (Int, Ptr e)

unsafeThaw :: SArray# e -> IO (Int, Ptr e)

(MonadIO io, Unboxed e) => Thaw io (SBytes# e) (MIOBytes# io e)

Defined in SDP.Prim.SBytes

Methods

thaw :: SBytes# e -> io (MIOBytes# io e)

unsafeThaw :: SBytes# e -> io (MIOBytes# io e)

MonadIO io => Thaw io (SArray# e) (MIOArray# io e)

Defined in SDP.Prim.SArray

Methods

thaw :: SArray# e -> io (MIOArray# io e)

unsafeThaw :: SArray# e -> io (MIOArray# io e)

Thaw1 m imm mut e => Thaw m (imm e) (AnyChunks mut e)

Creates one-chunk mutable stream, may be memory inefficient.

Defined in SDP.Templates.AnyChunks

Methods

thaw :: imm e -> m (AnyChunks mut e)

unsafeThaw :: imm e -> m (AnyChunks mut e)

(Linear1 imm e, Thaw1 m imm mut e) => Thaw m (AnyChunks imm e) (mut e)

Creates new local immutable structure and thaw it as fast, as possible.

Defined in SDP.Templates.AnyChunks

Methods

thaw :: AnyChunks imm e -> m (mut e)

unsafeThaw :: AnyChunks imm e -> m (mut e)

Thaw1 m imm mut e => Thaw m (AnyChunks imm e) (AnyChunks mut e)

Defined in SDP.Templates.AnyChunks

Methods

thaw :: AnyChunks imm e -> m (AnyChunks mut e)

unsafeThaw :: AnyChunks imm e -> m (AnyChunks mut e)

(Index i, Thaw m (rep e) mut) => Thaw m (AnyBorder rep i e) mut

Defined in SDP.Templates.AnyBorder

Methods

thaw :: AnyBorder rep i e -> m mut

unsafeThaw :: AnyBorder rep i e -> m mut

(Index i, Thaw1 m imm mut e) => Thaw m (AnyBorder imm i e) (AnyBorder mut i e)

Defined in SDP.Templates.AnyBorder

Methods

thaw :: AnyBorder imm i e -> m (AnyBorder mut i e)

unsafeThaw :: AnyBorder imm i e -> m (AnyBorder mut i e)

Unboxed e => Thaw (ST s) (SBytes# e) (STBytes# s e)

Defined in SDP.Prim.SBytes

Methods

thaw :: SBytes# e -> ST s (STBytes# s e)

unsafeThaw :: SBytes# e -> ST s (STBytes# s e)

Thaw (ST s) (SArray# e) (STArray# s e)

Defined in SDP.Prim.SArray

Methods

thaw :: SArray# e -> ST s (STArray# s e)

unsafeThaw :: SArray# e -> ST s (STArray# s e)

type Thaw1 m v v' e = Thaw m (v e) (v' e)

Kind (* -> *) Thaw.