SDP.LinearM

SDP.LinearM is a module that provides BorderedM and LinearM classes.

Exports

module SDP.Linear

BorderedM class

class (Monad m, Index i) => BorderedM m b i | b -> m, b -> i where

BorderedM is Bordered version for mutable data structures.

Minimal complete definition

(getBounds | getLower, getUpper)

Methods

getBounds :: b -> m (i, i)

getBounds returns bounds of mutable data structure.

getLower :: b -> m i

getLower returns lower bound of mutable data structure.

getUpper :: b -> m i

getUpper returns upper bound of mutable data structure.

getSizeOf :: b -> m Int

getSizeOf returns size of mutable data structure.

getSizesOf :: b -> m [Int]

getSizesOf returns sizes of mutable data structure.

nowIndexIn :: b -> i -> m Bool

nowIndexIn is indexIn version for mutable structures.

getOffsetOf :: b -> i -> m Int

getOffsetOf is offsetOf version for mutable structures.

getIndexOf :: b -> Int -> m i

getIndexOf is indexOf version for mutable structures.

getIndices :: b -> m [i]

getIndices returns indices of mutable data structure.

Instances

BorderedM STM (TArray# e) Int

Defined in SDP.Prim.TArray

Methods

getBounds :: TArray# e -> STM (Int, Int)

getLower :: TArray# e -> STM Int

getUpper :: TArray# e -> STM Int

getSizeOf :: TArray# e -> STM Int

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

nowIndexIn :: TArray# e -> Int -> STM Bool

getOffsetOf :: TArray# e -> Int -> STM Int

getIndexOf :: TArray# e -> Int -> STM Int

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

MonadIO io => BorderedM io (MIOBytes# io e) Int

Defined in SDP.Prim.SBytes

Methods

getBounds :: MIOBytes# io e -> io (Int, Int)

getLower :: MIOBytes# io e -> io Int

getUpper :: MIOBytes# io e -> io Int

getSizeOf :: MIOBytes# io e -> io Int

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

nowIndexIn :: MIOBytes# io e -> Int -> io Bool

getOffsetOf :: MIOBytes# io e -> Int -> io Int

getIndexOf :: MIOBytes# io e -> Int -> io Int

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

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

Defined in SDP.Prim.SArray

Methods

getBounds :: MIOArray# io e -> io (Int, Int)

getLower :: MIOArray# io e -> io Int

getUpper :: MIOArray# io e -> io Int

getSizeOf :: MIOArray# io e -> io Int

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

nowIndexIn :: MIOArray# io e -> Int -> io Bool

getOffsetOf :: MIOArray# io e -> Int -> io Int

getIndexOf :: MIOArray# io e -> Int -> io Int

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

BorderedM1 m rep Int e => BorderedM m (AnyChunks rep e) Int

Defined in SDP.Templates.AnyChunks

Methods

getBounds :: AnyChunks rep e -> m (Int, Int)

getLower :: AnyChunks rep e -> m Int

getUpper :: AnyChunks rep e -> m Int

getSizeOf :: AnyChunks rep e -> m Int

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

nowIndexIn :: AnyChunks rep e -> Int -> m Bool

getOffsetOf :: AnyChunks rep e -> Int -> m Int

getIndexOf :: AnyChunks rep e -> Int -> m Int

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

(Index i, BorderedM1 m rep Int e) => BorderedM m (AnyBorder rep i e) i

Defined in SDP.Templates.AnyBorder

Methods

getBounds :: AnyBorder rep i e -> m (i, i)

getLower :: AnyBorder rep i e -> m i

getUpper :: AnyBorder rep i e -> m i

getSizeOf :: AnyBorder rep i e -> m Int

getSizesOf :: AnyBorder rep i e -> m [Int]

nowIndexIn :: AnyBorder rep i e -> i -> m Bool

getOffsetOf :: AnyBorder rep i e -> i -> m Int

getIndexOf :: AnyBorder rep i e -> Int -> m i

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

BorderedM (ST s) (STBytes# s e) Int

Defined in SDP.Prim.SBytes

Methods

getBounds :: STBytes# s e -> ST s (Int, Int)

getLower :: STBytes# s e -> ST s Int

getUpper :: STBytes# s e -> ST s Int

getSizeOf :: STBytes# s e -> ST s Int

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

nowIndexIn :: STBytes# s e -> Int -> ST s Bool

getOffsetOf :: STBytes# s e -> Int -> ST s Int

getIndexOf :: STBytes# s e -> Int -> ST s Int

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

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

Defined in SDP.Prim.SArray

Methods

getBounds :: STArray# s e -> ST s (Int, Int)

getLower :: STArray# s e -> ST s Int

getUpper :: STArray# s e -> ST s Int

getSizeOf :: STArray# s e -> ST s Int

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

nowIndexIn :: STArray# s e -> Int -> ST s Bool

getOffsetOf :: STArray# s e -> Int -> ST s Int

getIndexOf :: STArray# s e -> Int -> ST s Int

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

type BorderedM1 m l i e = BorderedM m (l e) i

Kind (* -> *) BorderedM structure.

type BorderedM2 m l i e = BorderedM m (l i e) i

Kind (* -> * -> *) BorderedM structure.

LinearM class

class Monad m => LinearM m l e | l -> m, l -> e where

LinearM is Linear version for mutable data structures. This class is designed with the possibility of in-place implementation, so many operations from Linear have no analogues here.

Minimal complete definition

(newLinear | fromFoldableM), (getLeft | getRight), (!#>), writeM, copyTo

Methods

newNull :: m l

Monadic single.

nowNull :: l -> m Bool

Monadic isNull.

singleM :: e -> m l

Monadic single.

getHead :: l -> m e

getHead is monadic version of head. This procedure mustn't modify the source structure or return references to its mutable fields.

getLast :: l -> m e

getLast is monadic version of last. This procedure mustn't modify the source structure or return references to its mutable fields.

prepend :: e -> l -> m l

Prepends new element to the start of the structure (monadic toHead). Like most size-changing operations, prepend doesn't guarantee the correctness of the original structure after conversion.

append :: l -> e -> m l

Appends new element to the end of the structure (monadic toLast). Like most size-changing operations, append doesn't guarantee the correctness of the original structure after conversion.

newLinear :: [e] -> m l

Monadic fromList.

newLinearN :: Int -> [e] -> m l

Monadic fromListN.

fromFoldableM :: Foldable f => f e -> m l

Monadic fromFoldable.

getLeft :: l -> m [e]

Left view of line.

getRight :: l -> m [e]

Right view of line.

(!#>) :: l -> Int -> m e infixl 5

(!#>) is unsafe monadic offset-based reader.

writeM :: l -> Int -> e -> m ()

Unsafe monadic offset-based writer.

copied :: l -> m l

Create copy.

copied' :: l -> Int -> Int -> m l

copied' es l n returns the slice of es from l of length n.

reversed :: l -> m l

Monadic reverse.

merged :: Foldable f => f l -> m l

Monadic concat.

filled :: Int -> e -> m l

Monadic version of replicate.

copyTo :: l -> Int -> l -> Int -> Int -> m ()

copyTo source soff target toff count writes count elements of source from soff to target starting with toff.

ofoldrM :: (Int -> e -> r -> m r) -> r -> l -> m r

ofoldrM is right monadic fold with offset.

ofoldlM :: (Int -> r -> e -> m r) -> r -> l -> m r

ofoldlM is left monadic fold with offset.

ofoldrM' :: (Int -> e -> r -> m r) -> r -> l -> m r

ofoldrM' is strict version of ofoldrM.

ofoldlM' :: (Int -> r -> e -> m r) -> r -> l -> m r

ofoldrM' is strict version of ofoldrM.

foldrM :: (e -> r -> m r) -> r -> l -> m r

foldrM is just ofoldrM in Linear context.

foldlM :: (r -> e -> m r) -> r -> l -> m r

foldlM is just ofoldlM in Linear context.

foldrM' :: (e -> r -> m r) -> r -> l -> m r

foldrM' is strict version of foldrM.

foldlM' :: (r -> e -> m r) -> r -> l -> m r

foldlM' is strict version of foldlM.

swapM :: l -> Int -> Int -> m ()

Just swap two elements.

Instances

LinearM STM (TArray# e) e

Defined in SDP.Prim.TArray

Methods

newNull :: STM (TArray# e)

nowNull :: TArray# e -> STM Bool

singleM :: e -> STM (TArray# e)

getHead :: TArray# e -> STM e

getLast :: TArray# e -> STM e

prepend :: e -> TArray# e -> STM (TArray# e)

append :: TArray# e -> e -> STM (TArray# e)

newLinear :: [e] -> STM (TArray# e)

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

fromFoldableM :: Foldable f => f e -> STM (TArray# e)

getLeft :: TArray# e -> STM [e]

getRight :: TArray# e -> STM [e]

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

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

copied :: TArray# e -> STM (TArray# e)

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

reversed :: TArray# e -> STM (TArray# e)

merged :: Foldable f => f (TArray# e) -> STM (TArray# e)

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

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

ofoldrM :: (Int -> e -> r -> STM r) -> r -> TArray# e -> STM r

ofoldlM :: (Int -> r -> e -> STM r) -> r -> TArray# e -> STM r

ofoldrM' :: (Int -> e -> r -> STM r) -> r -> TArray# e -> STM r

ofoldlM' :: (Int -> r -> e -> STM r) -> r -> TArray# e -> STM r

foldrM :: (e -> r -> STM r) -> r -> TArray# e -> STM r

foldlM :: (r -> e -> STM r) -> r -> TArray# e -> STM r

foldrM' :: (e -> r -> STM r) -> r -> TArray# e -> STM r

foldlM' :: (r -> e -> STM r) -> r -> TArray# e -> STM r

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

(MonadIO io, Unboxed e) => LinearM io (MIOBytes# io e) e

Defined in SDP.Prim.SBytes

Methods

newNull :: io (MIOBytes# io e)

nowNull :: MIOBytes# io e -> io Bool

singleM :: e -> io (MIOBytes# io e)

getHead :: MIOBytes# io e -> io e

getLast :: MIOBytes# io e -> io e

prepend :: e -> MIOBytes# io e -> io (MIOBytes# io e)

append :: MIOBytes# io e -> e -> io (MIOBytes# io e)

newLinear :: [e] -> io (MIOBytes# io e)

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

fromFoldableM :: Foldable f => f e -> io (MIOBytes# io e)

getLeft :: MIOBytes# io e -> io [e]

getRight :: MIOBytes# io e -> io [e]

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

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

copied :: MIOBytes# io e -> io (MIOBytes# io e)

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

reversed :: MIOBytes# io e -> io (MIOBytes# io e)

merged :: Foldable f => f (MIOBytes# io e) -> io (MIOBytes# io e)

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

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

ofoldrM :: (Int -> e -> r -> io r) -> r -> MIOBytes# io e -> io r

ofoldlM :: (Int -> r -> e -> io r) -> r -> MIOBytes# io e -> io r

ofoldrM' :: (Int -> e -> r -> io r) -> r -> MIOBytes# io e -> io r

ofoldlM' :: (Int -> r -> e -> io r) -> r -> MIOBytes# io e -> io r

foldrM :: (e -> r -> io r) -> r -> MIOBytes# io e -> io r

foldlM :: (r -> e -> io r) -> r -> MIOBytes# io e -> io r

foldrM' :: (e -> r -> io r) -> r -> MIOBytes# io e -> io r

foldlM' :: (r -> e -> io r) -> r -> MIOBytes# io e -> io r

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

MonadIO io => LinearM io (MIOArray# io e) e

Defined in SDP.Prim.SArray

Methods

newNull :: io (MIOArray# io e)

nowNull :: MIOArray# io e -> io Bool

singleM :: e -> io (MIOArray# io e)

getHead :: MIOArray# io e -> io e

getLast :: MIOArray# io e -> io e

prepend :: e -> MIOArray# io e -> io (MIOArray# io e)

append :: MIOArray# io e -> e -> io (MIOArray# io e)

newLinear :: [e] -> io (MIOArray# io e)

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

fromFoldableM :: Foldable f => f e -> io (MIOArray# io e)

getLeft :: MIOArray# io e -> io [e]

getRight :: MIOArray# io e -> io [e]

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

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

copied :: MIOArray# io e -> io (MIOArray# io e)

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

reversed :: MIOArray# io e -> io (MIOArray# io e)

merged :: Foldable f => f (MIOArray# io e) -> io (MIOArray# io e)

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

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

ofoldrM :: (Int -> e -> r -> io r) -> r -> MIOArray# io e -> io r

ofoldlM :: (Int -> r -> e -> io r) -> r -> MIOArray# io e -> io r

ofoldrM' :: (Int -> e -> r -> io r) -> r -> MIOArray# io e -> io r

ofoldlM' :: (Int -> r -> e -> io r) -> r -> MIOArray# io e -> io r

foldrM :: (e -> r -> io r) -> r -> MIOArray# io e -> io r

foldlM :: (r -> e -> io r) -> r -> MIOArray# io e -> io r

foldrM' :: (e -> r -> io r) -> r -> MIOArray# io e -> io r

foldlM' :: (r -> e -> io r) -> r -> MIOArray# io e -> io r

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

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

Defined in SDP.Templates.AnyChunks

Methods

newNull :: m (AnyChunks rep e)

nowNull :: AnyChunks rep e -> m Bool

singleM :: e -> m (AnyChunks rep e)

getHead :: AnyChunks rep e -> m e

getLast :: AnyChunks rep e -> m e

prepend :: e -> AnyChunks rep e -> m (AnyChunks rep e)

append :: AnyChunks rep e -> e -> m (AnyChunks rep e)

newLinear :: [e] -> m (AnyChunks rep e)

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

fromFoldableM :: Foldable f => f e -> m (AnyChunks rep e)

getLeft :: AnyChunks rep e -> m [e]

getRight :: AnyChunks rep e -> m [e]

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

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

copied :: AnyChunks rep e -> m (AnyChunks rep e)

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

reversed :: AnyChunks rep e -> m (AnyChunks rep e)

merged :: Foldable f => f (AnyChunks rep e) -> m (AnyChunks rep e)

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

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

ofoldrM :: (Int -> e -> r -> m r) -> r -> AnyChunks rep e -> m r

ofoldlM :: (Int -> r -> e -> m r) -> r -> AnyChunks rep e -> m r

ofoldrM' :: (Int -> e -> r -> m r) -> r -> AnyChunks rep e -> m r

ofoldlM' :: (Int -> r -> e -> m r) -> r -> AnyChunks rep e -> m r

foldrM :: (e -> r -> m r) -> r -> AnyChunks rep e -> m r

foldlM :: (r -> e -> m r) -> r -> AnyChunks rep e -> m r

foldrM' :: (e -> r -> m r) -> r -> AnyChunks rep e -> m r

foldlM' :: (r -> e -> m r) -> r -> AnyChunks rep e -> m r

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

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

Defined in SDP.Templates.AnyBorder

Methods

newNull :: m (AnyBorder rep i e)

nowNull :: AnyBorder rep i e -> m Bool

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

getHead :: AnyBorder rep i e -> m e

getLast :: AnyBorder rep i e -> m e

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

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

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

newLinearN :: Int -> [e] -> m (AnyBorder rep i e)

fromFoldableM :: Foldable f => f e -> m (AnyBorder rep i e)

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

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

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

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

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

copied' :: AnyBorder rep i e -> Int -> Int -> m (AnyBorder rep i e)

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

merged :: Foldable f => f (AnyBorder rep i e) -> m (AnyBorder rep i e)

filled :: Int -> e -> m (AnyBorder rep i e)

copyTo :: AnyBorder rep i e -> Int -> AnyBorder rep i e -> Int -> Int -> m ()

ofoldrM :: (Int -> e -> r -> m r) -> r -> AnyBorder rep i e -> m r

ofoldlM :: (Int -> r -> e -> m r) -> r -> AnyBorder rep i e -> m r

ofoldrM' :: (Int -> e -> r -> m r) -> r -> AnyBorder rep i e -> m r

ofoldlM' :: (Int -> r -> e -> m r) -> r -> AnyBorder rep i e -> m r

foldrM :: (e -> r -> m r) -> r -> AnyBorder rep i e -> m r

foldlM :: (r -> e -> m r) -> r -> AnyBorder rep i e -> m r

foldrM' :: (e -> r -> m r) -> r -> AnyBorder rep i e -> m r

foldlM' :: (r -> e -> m r) -> r -> AnyBorder rep i e -> m r

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

Unboxed e => LinearM (ST s) (STBytes# s e) e

Defined in SDP.Prim.SBytes

Methods

newNull :: ST s (STBytes# s e)

nowNull :: STBytes# s e -> ST s Bool

singleM :: e -> ST s (STBytes# s e)

getHead :: STBytes# s e -> ST s e

getLast :: STBytes# s e -> ST s e

prepend :: e -> STBytes# s e -> ST s (STBytes# s e)

append :: STBytes# s e -> e -> ST s (STBytes# s e)

newLinear :: [e] -> ST s (STBytes# s e)

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

fromFoldableM :: Foldable f => f e -> ST s (STBytes# s e)

getLeft :: STBytes# s e -> ST s [e]

getRight :: STBytes# s e -> ST s [e]

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

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

copied :: STBytes# s e -> ST s (STBytes# s e)

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

reversed :: STBytes# s e -> ST s (STBytes# s e)

merged :: Foldable f => f (STBytes# s e) -> ST s (STBytes# s e)

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

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

ofoldrM :: (Int -> e -> r -> ST s r) -> r -> STBytes# s e -> ST s r

ofoldlM :: (Int -> r -> e -> ST s r) -> r -> STBytes# s e -> ST s r

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

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

foldrM :: (e -> r -> ST s r) -> r -> STBytes# s e -> ST s r

foldlM :: (r -> e -> ST s r) -> r -> STBytes# s e -> ST s r

foldrM' :: (e -> r -> ST s r) -> r -> STBytes# s e -> ST s r

foldlM' :: (r -> e -> ST s r) -> r -> STBytes# s e -> ST s r

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

LinearM (ST s) (STArray# s e) e

Defined in SDP.Prim.SArray

Methods

newNull :: ST s (STArray# s e)

nowNull :: STArray# s e -> ST s Bool

singleM :: e -> ST s (STArray# s e)

getHead :: STArray# s e -> ST s e

getLast :: STArray# s e -> ST s e

prepend :: e -> STArray# s e -> ST s (STArray# s e)

append :: STArray# s e -> e -> ST s (STArray# s e)

newLinear :: [e] -> ST s (STArray# s e)

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

fromFoldableM :: Foldable f => f e -> ST s (STArray# s e)

getLeft :: STArray# s e -> ST s [e]

getRight :: STArray# s e -> ST s [e]

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

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

copied :: STArray# s e -> ST s (STArray# s e)

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

reversed :: STArray# s e -> ST s (STArray# s e)

merged :: Foldable f => f (STArray# s e) -> ST s (STArray# s e)

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

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

ofoldrM :: (Int -> e -> r -> ST s r) -> r -> STArray# s e -> ST s r

ofoldlM :: (Int -> r -> e -> ST s r) -> r -> STArray# s e -> ST s r

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

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

foldrM :: (e -> r -> ST s r) -> r -> STArray# s e -> ST s r

foldlM :: (r -> e -> ST s r) -> r -> STArray# s e -> ST s r

foldrM' :: (e -> r -> ST s r) -> r -> STArray# s e -> ST s r

foldlM' :: (r -> e -> ST s r) -> r -> STArray# s e -> ST s r

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

type LinearM1 m l e = LinearM m (l e) e

Kind (* -> *) LinearM structure.

SplitM class

class LinearM m s e => SplitM m s e where

SplitM is Split version for mutable data structures. This class is designed with the possibility of in-place implementation, so many operations from Split have no analogues here.

Minimal complete definition

(takeM | sansM), (dropM | keepM)

Methods

takeM :: Int -> s -> m s

takeM n es returns a reference to the es, keeping first n elements. Changes in the source and result must be synchronous.

default takeM :: BorderedM m s i => Int -> s -> m s

dropM :: Int -> s -> m s

dropM n es returns a reference to the es, discarding first n elements. Changes in the source and result must be synchronous.

default dropM :: BorderedM m s i => Int -> s -> m s

keepM :: Int -> s -> m s

keepM n es returns a reference to the es, keeping last n elements. Changes in the source and result must be synchronous.

default keepM :: BorderedM m s i => Int -> s -> m s

sansM :: Int -> s -> m s

sansM n es returns a reference to the es, discarding last n elements. Changes in the source and result must be synchronous.

default sansM :: BorderedM m s i => Int -> s -> m s

splitM :: Int -> s -> m (s, s)

splitM n es returns pair of references to the es: keeping and discarding first n elements. Changes in the source and result must be synchronous.

divideM :: Int -> s -> m (s, s)

divideM n es returns pair of references to the es: discarding and keeping last n elements. Changes in the source and results must be synchronous.

splitsM :: Foldable f => f Int -> s -> m [s]

splitM ns es returns the sequence of es prefix references of length n <- ns. Changes in the source and results must be synchronous.

dividesM :: Foldable f => f Int -> s -> m [s]

dividesM ns es returns the sequence of es suffix references of length n <- ns. Changes in the source and results must be synchronous.

partsM :: Foldable f => f Int -> s -> m [s]

partsM n es returns the sequence of es prefix references, splitted by offsets in es. Changes in the source and results must be synchronous.

chunksM :: Int -> s -> m [s]

chunksM n es returns the sequence of es prefix references of length n. Changes in the source and results must be synchronous.

eachM :: Int -> s -> m s

eachM n es returns new sequence of es elements with step n. eachM shouldn't return references to es.

prefixM :: (e -> Bool) -> s -> m Int

prefixM p es returns the longest es prefix size, satisfying p.

suffixM :: (e -> Bool) -> s -> m Int

suffixM p es returns the longest es suffix size, satisfying p.

mprefix :: (e -> m Bool) -> s -> m Int

mprefix p es returns the longest es prefix size, satisfying p.

msuffix :: (e -> m Bool) -> s -> m Int

msuffix p es returns the longest es suffix size, satisfying p.

Instances

SplitM STM (TArray# e) e

Defined in SDP.Prim.TArray

Methods

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

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

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

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

splitM :: Int -> TArray# e -> STM (TArray# e, TArray# e)

divideM :: Int -> TArray# e -> STM (TArray# e, TArray# e)

splitsM :: Foldable f => f Int -> TArray# e -> STM [TArray# e]

dividesM :: Foldable f => f Int -> TArray# e -> STM [TArray# e]

partsM :: Foldable f => f Int -> TArray# e -> STM [TArray# e]

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

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

prefixM :: (e -> Bool) -> TArray# e -> STM Int

suffixM :: (e -> Bool) -> TArray# e -> STM Int

mprefix :: (e -> STM Bool) -> TArray# e -> STM Int

msuffix :: (e -> STM Bool) -> TArray# e -> STM Int

(MonadIO io, Unboxed e) => SplitM io (MIOBytes# io e) e

Defined in SDP.Prim.SBytes

Methods

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

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

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

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

splitM :: Int -> MIOBytes# io e -> io (MIOBytes# io e, MIOBytes# io e)

divideM :: Int -> MIOBytes# io e -> io (MIOBytes# io e, MIOBytes# io e)

splitsM :: Foldable f => f Int -> MIOBytes# io e -> io [MIOBytes# io e]

dividesM :: Foldable f => f Int -> MIOBytes# io e -> io [MIOBytes# io e]

partsM :: Foldable f => f Int -> MIOBytes# io e -> io [MIOBytes# io e]

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

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

prefixM :: (e -> Bool) -> MIOBytes# io e -> io Int

suffixM :: (e -> Bool) -> MIOBytes# io e -> io Int

mprefix :: (e -> io Bool) -> MIOBytes# io e -> io Int

msuffix :: (e -> io Bool) -> MIOBytes# io e -> io Int

MonadIO io => SplitM io (MIOArray# io e) e

Defined in SDP.Prim.SArray

Methods

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

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

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

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

splitM :: Int -> MIOArray# io e -> io (MIOArray# io e, MIOArray# io e)

divideM :: Int -> MIOArray# io e -> io (MIOArray# io e, MIOArray# io e)

splitsM :: Foldable f => f Int -> MIOArray# io e -> io [MIOArray# io e]

dividesM :: Foldable f => f Int -> MIOArray# io e -> io [MIOArray# io e]

partsM :: Foldable f => f Int -> MIOArray# io e -> io [MIOArray# io e]

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

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

prefixM :: (e -> Bool) -> MIOArray# io e -> io Int

suffixM :: (e -> Bool) -> MIOArray# io e -> io Int

mprefix :: (e -> io Bool) -> MIOArray# io e -> io Int

msuffix :: (e -> io Bool) -> MIOArray# io e -> io Int

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

Defined in SDP.Templates.AnyChunks

Methods

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

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

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

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

splitM :: Int -> AnyChunks rep e -> m (AnyChunks rep e, AnyChunks rep e)

divideM :: Int -> AnyChunks rep e -> m (AnyChunks rep e, AnyChunks rep e)

splitsM :: Foldable f => f Int -> AnyChunks rep e -> m [AnyChunks rep e]

dividesM :: Foldable f => f Int -> AnyChunks rep e -> m [AnyChunks rep e]

partsM :: Foldable f => f Int -> AnyChunks rep e -> m [AnyChunks rep e]

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

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

prefixM :: (e -> Bool) -> AnyChunks rep e -> m Int

suffixM :: (e -> Bool) -> AnyChunks rep e -> m Int

mprefix :: (e -> m Bool) -> AnyChunks rep e -> m Int

msuffix :: (e -> m Bool) -> AnyChunks rep e -> m Int

(Index i, BorderedM1 m rep Int e, SplitM1 m rep e) => SplitM m (AnyBorder rep i e) e

Defined in SDP.Templates.AnyBorder

Methods

takeM :: Int -> AnyBorder rep i e -> m (AnyBorder rep i e)

dropM :: Int -> AnyBorder rep i e -> m (AnyBorder rep i e)

keepM :: Int -> AnyBorder rep i e -> m (AnyBorder rep i e)

sansM :: Int -> AnyBorder rep i e -> m (AnyBorder rep i e)

splitM :: Int -> AnyBorder rep i e -> m (AnyBorder rep i e, AnyBorder rep i e)

divideM :: Int -> AnyBorder rep i e -> m (AnyBorder rep i e, AnyBorder rep i e)

splitsM :: Foldable f => f Int -> AnyBorder rep i e -> m [AnyBorder rep i e]

dividesM :: Foldable f => f Int -> AnyBorder rep i e -> m [AnyBorder rep i e]

partsM :: Foldable f => f Int -> AnyBorder rep i e -> m [AnyBorder rep i e]

chunksM :: Int -> AnyBorder rep i e -> m [AnyBorder rep i e]

eachM :: Int -> AnyBorder rep i e -> m (AnyBorder rep i e)

prefixM :: (e -> Bool) -> AnyBorder rep i e -> m Int

suffixM :: (e -> Bool) -> AnyBorder rep i e -> m Int

mprefix :: (e -> m Bool) -> AnyBorder rep i e -> m Int

msuffix :: (e -> m Bool) -> AnyBorder rep i e -> m Int

Unboxed e => SplitM (ST s) (STBytes# s e) e

Defined in SDP.Prim.SBytes

Methods

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

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

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

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

splitM :: Int -> STBytes# s e -> ST s (STBytes# s e, STBytes# s e)

divideM :: Int -> STBytes# s e -> ST s (STBytes# s e, STBytes# s e)

splitsM :: Foldable f => f Int -> STBytes# s e -> ST s [STBytes# s e]

dividesM :: Foldable f => f Int -> STBytes# s e -> ST s [STBytes# s e]

partsM :: Foldable f => f Int -> STBytes# s e -> ST s [STBytes# s e]

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

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

prefixM :: (e -> Bool) -> STBytes# s e -> ST s Int

suffixM :: (e -> Bool) -> STBytes# s e -> ST s Int

mprefix :: (e -> ST s Bool) -> STBytes# s e -> ST s Int

msuffix :: (e -> ST s Bool) -> STBytes# s e -> ST s Int

SplitM (ST s) (STArray# s e) e

Defined in SDP.Prim.SArray

Methods

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

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

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

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

splitM :: Int -> STArray# s e -> ST s (STArray# s e, STArray# s e)

divideM :: Int -> STArray# s e -> ST s (STArray# s e, STArray# s e)

splitsM :: Foldable f => f Int -> STArray# s e -> ST s [STArray# s e]

dividesM :: Foldable f => f Int -> STArray# s e -> ST s [STArray# s e]

partsM :: Foldable f => f Int -> STArray# s e -> ST s [STArray# s e]

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

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

prefixM :: (e -> Bool) -> STArray# s e -> ST s Int

suffixM :: (e -> Bool) -> STArray# s e -> ST s Int

mprefix :: (e -> ST s Bool) -> STArray# s e -> ST s Int

msuffix :: (e -> ST s Bool) -> STArray# s e -> ST s Int

type SplitM1 m l e = SplitM m (l e) e

Kind (* -> *) SplitM structure.