SDP.Prim.SArray

SDP.Prim.SArray provides lazy boxed array pseudo-primitive types SArray#, STArray# and IOArray#.

Exports

module SDP.IndexedM

module SDP.SortM

module SDP.Sort

Pseudo-primitive types

newtype MIOArray# (io :: Type -> Type) e

MIOArray# is mutable preudo-primitive Int-indexed lazy boxed array.

Constructors

MIOArray# (STArray# RealWorld e)

Instances

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)

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

Defined in SDP.Prim.SArray

Methods

sortedMBy :: (e -> e -> Bool) -> MIOArray# io e -> io Bool

sortMBy :: Compare e -> MIOArray# io e -> io ()

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

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 ()

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]

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

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 ()

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

Defined in SDP.Prim.SArray

Methods

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

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

Eq (MIOArray# io e)

Defined in SDP.Prim.SArray

Methods

(==) :: MIOArray# io e -> MIOArray# io e -> Bool

(/=) :: MIOArray# io e -> MIOArray# io e -> Bool

Estimate (MIOArray# io e)

Defined in SDP.Prim.SArray

Methods

(<.=>) :: MIOArray# io e -> Int -> Ordering

(<==>) :: Compare (MIOArray# io e)

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

(./=) :: MIOArray# io e -> Int -> Bool

(.<=) :: MIOArray# io e -> Int -> Bool

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

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

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

(.<.) :: MIOArray# io e -> MIOArray# io e -> Bool

(.>.) :: MIOArray# io e -> MIOArray# io e -> Bool

(.<=.) :: MIOArray# io e -> MIOArray# io e -> Bool

(.>=.) :: MIOArray# io e -> MIOArray# io e -> Bool

(.==.) :: MIOArray# io e -> MIOArray# io e -> Bool

(./=.) :: MIOArray# io e -> MIOArray# io e -> Bool

Bordered (MIOArray# io e) Int

Defined in SDP.Prim.SArray

Methods

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

lower :: MIOArray# io e -> Int

upper :: MIOArray# io e -> Int

sizeOf :: MIOArray# io e -> Int

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

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

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

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

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

type IOArray# = MIOArray# IO

IOArray# is mutable preudo-primitive Int-indexed lazy boxed array.

data STArray# s e

STArray# is mutable preudo-primitive Int-indexed lazy boxed array type.

Instances

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)

SortM (ST s) (STArray# s e) e

Defined in SDP.Prim.SArray

Methods

sortedMBy :: (e -> e -> Bool) -> STArray# s e -> ST s Bool

sortMBy :: Compare e -> STArray# s e -> ST s ()

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

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 ()

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]

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

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 ()

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

Defined in SDP.Prim.SArray

Methods

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

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

Eq (STArray# s e)

Defined in SDP.Prim.SArray

Methods

(==) :: STArray# s e -> STArray# s e -> Bool

(/=) :: STArray# s e -> STArray# s e -> Bool

Estimate (STArray# s e)

Defined in SDP.Prim.SArray

Methods

(<.=>) :: STArray# s e -> Int -> Ordering

(<==>) :: Compare (STArray# s e)

(.==) :: STArray# s e -> Int -> Bool

(./=) :: STArray# s e -> Int -> Bool

(.<=) :: STArray# s e -> Int -> Bool

(.>=) :: STArray# s e -> Int -> Bool

(.<) :: STArray# s e -> Int -> Bool

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

(.<.) :: STArray# s e -> STArray# s e -> Bool

(.>.) :: STArray# s e -> STArray# s e -> Bool

(.<=.) :: STArray# s e -> STArray# s e -> Bool

(.>=.) :: STArray# s e -> STArray# s e -> Bool

(.==.) :: STArray# s e -> STArray# s e -> Bool

(./=.) :: STArray# s e -> STArray# s e -> Bool

Bordered (STArray# s e) Int

Defined in SDP.Prim.SArray

Methods

bounds :: STArray# s e -> (Int, Int)

lower :: STArray# s e -> Int

upper :: STArray# s e -> Int

sizeOf :: STArray# s e -> Int

sizesOf :: STArray# s e -> [Int]

indexIn :: STArray# s e -> Int -> Bool

indices :: STArray# s e -> [Int]

indexOf :: STArray# s e -> Int -> Int

offsetOf :: STArray# s e -> Int -> Int

data SArray# e

SArray# is immutable pseudo-primitive Int-indexed lazy boxed array type.

SArray# isn't real Haskell primitive (like GHC.Exts types) but for reliability and stability, I made it inaccessible to direct work.

Instances

Functor SArray#

Defined in SDP.Prim.SArray

Methods

fmap :: (a -> b) -> SArray# a -> SArray# b

(<$) :: a -> SArray# b -> SArray# a

Applicative SArray#

Defined in SDP.Prim.SArray

Methods

pure :: a -> SArray# a

(<*>) :: SArray# (a -> b) -> SArray# a -> SArray# b

liftA2 :: (a -> b -> c) -> SArray# a -> SArray# b -> SArray# c

(*>) :: SArray# a -> SArray# b -> SArray# b

(<*) :: SArray# a -> SArray# b -> SArray# a

Foldable SArray#

Defined in SDP.Prim.SArray

Methods

fold :: Monoid m => SArray# m -> m

foldMap :: Monoid m => (a -> m) -> SArray# a -> m

foldMap' :: Monoid m => (a -> m) -> SArray# a -> m

foldr :: (a -> b -> b) -> b -> SArray# a -> b

foldr' :: (a -> b -> b) -> b -> SArray# a -> b

foldl :: (b -> a -> b) -> b -> SArray# a -> b

foldl' :: (b -> a -> b) -> b -> SArray# a -> b

foldr1 :: (a -> a -> a) -> SArray# a -> a

foldl1 :: (a -> a -> a) -> SArray# a -> a

toList :: SArray# a -> [a]

null :: SArray# a -> Bool

length :: SArray# a -> Int

elem :: Eq a => a -> SArray# a -> Bool

maximum :: Ord a => SArray# a -> a

minimum :: Ord a => SArray# a -> a

sum :: Num a => SArray# a -> a

product :: Num a => SArray# a -> a

Traversable SArray#

Defined in SDP.Prim.SArray

Methods

traverse :: Applicative f => (a -> f b) -> SArray# a -> f (SArray# b)

sequenceA :: Applicative f => SArray# (f a) -> f (SArray# a)

mapM :: Monad m => (a -> m b) -> SArray# a -> m (SArray# b)

sequence :: Monad m => SArray# (m a) -> m (SArray# a)

Eq1 SArray#

Defined in SDP.Prim.SArray

Methods

liftEq :: (a -> b -> Bool) -> SArray# a -> SArray# b -> Bool

Eq1 Unlist

Defined in SDP.Unrolled.Unlist

Methods

liftEq :: (a -> b -> Bool) -> Unlist a -> Unlist b -> Bool

Ord1 SArray#

Defined in SDP.Prim.SArray

Methods

liftCompare :: (a -> b -> Ordering) -> SArray# a -> SArray# b -> Ordering

Ord1 Unlist

Defined in SDP.Unrolled.Unlist

Methods

liftCompare :: (a -> b -> Ordering) -> Unlist a -> Unlist b -> Ordering

Zip SArray#

Defined in SDP.Prim.SArray

Methods

zap :: SArray# (a -> b) -> SArray# a -> SArray# b

all2 :: (a -> b -> Bool) -> SArray# a -> SArray# b -> Bool

all3 :: (a -> b -> c -> Bool) -> SArray# a -> SArray# b -> SArray# c -> Bool

all4 :: (a -> b -> c -> d -> Bool) -> SArray# a -> SArray# b -> SArray# c -> SArray# d -> Bool

all5 :: (a -> b -> c -> d -> e -> Bool) -> SArray# a -> SArray# b -> SArray# c -> SArray# d -> SArray# e -> Bool

all6 :: (a -> b -> c -> d -> e -> f -> Bool) -> SArray# a -> SArray# b -> SArray# c -> SArray# d -> SArray# e -> SArray# f -> Bool

any2 :: (a -> b -> Bool) -> SArray# a -> SArray# b -> Bool

any3 :: (a -> b -> c -> Bool) -> SArray# a -> SArray# b -> SArray# c -> Bool

any4 :: (a -> b -> c -> d -> Bool) -> SArray# a -> SArray# b -> SArray# c -> SArray# d -> Bool

any5 :: (a -> b -> c -> d -> e -> Bool) -> SArray# a -> SArray# b -> SArray# c -> SArray# d -> SArray# e -> Bool

any6 :: (a -> b -> c -> d -> e -> f -> Bool) -> SArray# a -> SArray# b -> SArray# c -> SArray# d -> SArray# e -> SArray# f -> Bool

zip :: SArray# a -> SArray# b -> SArray# (a, b)

zip3 :: SArray# a -> SArray# b -> SArray# c -> SArray# (a, b, c)

zip4 :: SArray# a -> SArray# b -> SArray# c -> SArray# d -> SArray# (a, b, c, d)

zip5 :: SArray# a -> SArray# b -> SArray# c -> SArray# d -> SArray# e -> SArray# (a, b, c, d, e)

zip6 :: SArray# a -> SArray# b -> SArray# c -> SArray# d -> SArray# e -> SArray# f -> SArray# (a, b, c, d, e, f)

zipWith :: (a -> b -> c) -> SArray# a -> SArray# b -> SArray# c

zipWith3 :: (a -> b -> c -> d) -> SArray# a -> SArray# b -> SArray# c -> SArray# d

zipWith4 :: (a -> b -> c -> d -> e) -> SArray# a -> SArray# b -> SArray# c -> SArray# d -> SArray# e

zipWith5 :: (a -> b -> c -> d -> e -> f) -> SArray# a -> SArray# b -> SArray# c -> SArray# d -> SArray# e -> SArray# f

zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> SArray# a -> SArray# b -> SArray# c -> SArray# d -> SArray# e -> SArray# f -> SArray# g

Zip Unlist

Defined in SDP.Unrolled.Unlist

Methods

zap :: Unlist (a -> b) -> Unlist a -> Unlist b

all2 :: (a -> b -> Bool) -> Unlist a -> Unlist b -> Bool

all3 :: (a -> b -> c -> Bool) -> Unlist a -> Unlist b -> Unlist c -> Bool

all4 :: (a -> b -> c -> d -> Bool) -> Unlist a -> Unlist b -> Unlist c -> Unlist d -> Bool

all5 :: (a -> b -> c -> d -> e -> Bool) -> Unlist a -> Unlist b -> Unlist c -> Unlist d -> Unlist e -> Bool

all6 :: (a -> b -> c -> d -> e -> f -> Bool) -> Unlist a -> Unlist b -> Unlist c -> Unlist d -> Unlist e -> Unlist f -> Bool

any2 :: (a -> b -> Bool) -> Unlist a -> Unlist b -> Bool

any3 :: (a -> b -> c -> Bool) -> Unlist a -> Unlist b -> Unlist c -> Bool

any4 :: (a -> b -> c -> d -> Bool) -> Unlist a -> Unlist b -> Unlist c -> Unlist d -> Bool

any5 :: (a -> b -> c -> d -> e -> Bool) -> Unlist a -> Unlist b -> Unlist c -> Unlist d -> Unlist e -> Bool

any6 :: (a -> b -> c -> d -> e -> f -> Bool) -> Unlist a -> Unlist b -> Unlist c -> Unlist d -> Unlist e -> Unlist f -> Bool

zip :: Unlist a -> Unlist b -> Unlist (a, b)

zip3 :: Unlist a -> Unlist b -> Unlist c -> Unlist (a, b, c)

zip4 :: Unlist a -> Unlist b -> Unlist c -> Unlist d -> Unlist (a, b, c, d)

zip5 :: Unlist a -> Unlist b -> Unlist c -> Unlist d -> Unlist e -> Unlist (a, b, c, d, e)

zip6 :: Unlist a -> Unlist b -> Unlist c -> Unlist d -> Unlist e -> Unlist f -> Unlist (a, b, c, d, e, f)

zipWith :: (a -> b -> c) -> Unlist a -> Unlist b -> Unlist c

zipWith3 :: (a -> b -> c -> d) -> Unlist a -> Unlist b -> Unlist c -> Unlist d

zipWith4 :: (a -> b -> c -> d -> e) -> Unlist a -> Unlist b -> Unlist c -> Unlist d -> Unlist e

zipWith5 :: (a -> b -> c -> d -> e -> f) -> Unlist a -> Unlist b -> Unlist c -> Unlist d -> Unlist e -> Unlist f

zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> Unlist a -> Unlist b -> Unlist c -> Unlist d -> Unlist e -> Unlist f -> Unlist g

Freeze STM (TArray# e) (SArray# e)

Defined in SDP.Prim.TArray

Methods

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

unsafeFreeze :: TArray# e -> STM (SArray# 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 => 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 => 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)

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

Defined in SDP.Prim.SArray

Methods

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

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

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

Defined in SDP.Prim.SArray

Methods

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

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

IsList (SArray# e)

Defined in SDP.Prim.SArray

Associated Types

type Item (SArray# e)

Methods

fromList :: [Item (SArray# e)] -> SArray# e

fromListN :: Int -> [Item (SArray# e)] -> SArray# e

toList :: SArray# e -> [Item (SArray# e)]

Eq e => Eq (SArray# e)

Defined in SDP.Prim.SArray

Methods

(==) :: SArray# e -> SArray# e -> Bool

(/=) :: SArray# e -> SArray# e -> Bool

Ord e => Ord (SArray# e)

Defined in SDP.Prim.SArray

Methods

compare :: SArray# e -> SArray# e -> Ordering

(<) :: SArray# e -> SArray# e -> Bool

(<=) :: SArray# e -> SArray# e -> Bool

(>) :: SArray# e -> SArray# e -> Bool

(>=) :: SArray# e -> SArray# e -> Bool

max :: SArray# e -> SArray# e -> SArray# e

min :: SArray# e -> SArray# e -> SArray# e

Read e => Read (SArray# e)

Defined in SDP.Prim.SArray

Methods

readsPrec :: Int -> ReadS (SArray# e)

readList :: ReadS [SArray# e]

readPrec :: ReadPrec (SArray# e)

readListPrec :: ReadPrec [SArray# e]

Show e => Show (SArray# e)

Defined in SDP.Prim.SArray

Methods

showsPrec :: Int -> SArray# e -> ShowS

show :: SArray# e -> String

showList :: [SArray# e] -> ShowS

IsString (SArray# Char)

Defined in SDP.Prim.SArray

Methods

fromString :: String -> SArray# Char

Semigroup (SArray# e)

Defined in SDP.Prim.SArray

Methods

(<>) :: SArray# e -> SArray# e -> SArray# e

sconcat :: NonEmpty (SArray# e) -> SArray# e

stimes :: Integral b => b -> SArray# e -> SArray# e

Monoid (SArray# e)

Defined in SDP.Prim.SArray

Methods

mempty :: SArray# e

mappend :: SArray# e -> SArray# e -> SArray# e

mconcat :: [SArray# e] -> SArray# e

Default (SArray# e)

Defined in SDP.Prim.SArray

Methods

def :: SArray# e

Estimate (SArray# e)

Defined in SDP.Prim.SArray

Methods

(<.=>) :: SArray# e -> Int -> Ordering

(<==>) :: Compare (SArray# e)

(.==) :: SArray# e -> Int -> Bool

(./=) :: SArray# e -> Int -> Bool

(.<=) :: SArray# e -> Int -> Bool

(.>=) :: SArray# e -> Int -> Bool

(.<) :: SArray# e -> Int -> Bool

(.>) :: SArray# e -> Int -> Bool

(.<.) :: SArray# e -> SArray# e -> Bool

(.>.) :: SArray# e -> SArray# e -> Bool

(.<=.) :: SArray# e -> SArray# e -> Bool

(.>=.) :: SArray# e -> SArray# e -> Bool

(.==.) :: SArray# e -> SArray# e -> Bool

(./=.) :: SArray# e -> SArray# e -> Bool

Nullable (SArray# e)

Defined in SDP.Prim.SArray

Methods

lzero :: SArray# e

isNull :: SArray# e -> Bool

Sort (SArray# e) e

Defined in SDP.Prim.SArray

Methods

sortedBy :: (e -> e -> Bool) -> SArray# e -> Bool

sortBy :: Compare e -> SArray# e -> SArray# e

Sort (Unlist e) e

Defined in SDP.Unrolled.Unlist

Methods

sortedBy :: (e -> e -> Bool) -> Unlist e -> Bool

sortBy :: Compare e -> Unlist e -> Unlist e

Split (SArray# e) e

Defined in SDP.Prim.SArray

Methods

take :: Int -> SArray# e -> SArray# e

drop :: Int -> SArray# e -> SArray# e

keep :: Int -> SArray# e -> SArray# e

sans :: Int -> SArray# e -> SArray# e

save :: Int -> SArray# e -> SArray# e

skip :: Int -> SArray# e -> SArray# e

split :: Int -> SArray# e -> (SArray# e, SArray# e)

divide :: Int -> SArray# e -> (SArray# e, SArray# e)

splits :: Foldable f => f Int -> SArray# e -> [SArray# e]

divides :: Foldable f => f Int -> SArray# e -> [SArray# e]

parts :: Foldable f => f Int -> SArray# e -> [SArray# e]

chunks :: Int -> SArray# e -> [SArray# e]

splitBy :: (e -> Bool) -> SArray# e -> (SArray# e, SArray# e)

divideBy :: (e -> Bool) -> SArray# e -> (SArray# e, SArray# e)

splitsBy :: (e -> Bool) -> SArray# e -> [SArray# e]

splitsOn :: SArray# e -> SArray# e -> [SArray# e]

replaceBy :: SArray# e -> SArray# e -> SArray# e -> SArray# e

removeAll :: SArray# e -> SArray# e -> SArray# e

combo :: Equal e -> SArray# e -> Int

justifyL :: Int -> e -> SArray# e -> SArray# e

justifyR :: Int -> e -> SArray# e -> SArray# e

each :: Int -> SArray# e -> SArray# e

eachFrom :: Int -> Int -> SArray# e -> SArray# e

isPrefixOf :: SArray# e -> SArray# e -> Bool

isSuffixOf :: SArray# e -> SArray# e -> Bool

isInfixOf :: SArray# e -> SArray# e -> Bool

prefix :: (e -> Bool) -> SArray# e -> Int

suffix :: (e -> Bool) -> SArray# e -> Int

infixes :: SArray# e -> SArray# e -> [Int]

dropSide :: (e -> Bool) -> SArray# e -> SArray# e

takeWhile :: (e -> Bool) -> SArray# e -> SArray# e

dropWhile :: (e -> Bool) -> SArray# e -> SArray# e

takeEnd :: (e -> Bool) -> SArray# e -> SArray# e

dropEnd :: (e -> Bool) -> SArray# e -> SArray# e

spanl :: (e -> Bool) -> SArray# e -> (SArray# e, SArray# e)

breakl :: (e -> Bool) -> SArray# e -> (SArray# e, SArray# e)

spanr :: (e -> Bool) -> SArray# e -> (SArray# e, SArray# e)

breakr :: (e -> Bool) -> SArray# e -> (SArray# e, SArray# e)

selectWhile :: (e -> Maybe a) -> SArray# e -> [a]

selectEnd :: (e -> Maybe a) -> SArray# e -> [a]

extractWhile :: (e -> Maybe a) -> SArray# e -> ([a], SArray# e)

extractEnd :: (e -> Maybe a) -> SArray# e -> (SArray# e, [a])

selectWhile' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> SArray# e -> t a

selectEnd' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> SArray# e -> t a

extractWhile' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> SArray# e -> (t a, SArray# e)

extractEnd' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> SArray# e -> (SArray# e, t a)

Linear (SArray# e) e

Defined in SDP.Prim.SArray

Methods

uncons :: SArray# e -> (e, SArray# e)

uncons' :: SArray# e -> Maybe (e, SArray# e)

toHead :: e -> SArray# e -> SArray# e

head :: SArray# e -> e

tail :: SArray# e -> SArray# e

unsnoc :: SArray# e -> (SArray# e, e)

unsnoc' :: SArray# e -> Maybe (SArray# e, e)

toLast :: SArray# e -> e -> SArray# e

init :: SArray# e -> SArray# e

last :: SArray# e -> e

single :: e -> SArray# e

(++) :: SArray# e -> SArray# e -> SArray# e

replicate :: Int -> e -> SArray# e

fromList :: [e] -> SArray# e

fromListN :: Int -> [e] -> SArray# e

listR :: SArray# e -> [e]

listL :: SArray# e -> [e]

fromFoldable :: Foldable f => f e -> SArray# e

(!^) :: SArray# e -> Int -> e

write :: SArray# e -> Int -> e -> SArray# e

concat :: Foldable f => f (SArray# e) -> SArray# e

concatMap :: Foldable f => (a -> SArray# e) -> f a -> SArray# e

intersperse :: e -> SArray# e -> SArray# e

filter :: (e -> Bool) -> SArray# e -> SArray# e

except :: (e -> Bool) -> SArray# e -> SArray# e

partition :: (e -> Bool) -> SArray# e -> (SArray# e, SArray# e)

partitions :: Foldable f => f (e -> Bool) -> SArray# e -> [SArray# e]

select :: (e -> Maybe a) -> SArray# e -> [a]

select' :: (t e ~ SArray# e, Linear1 t a) => (e -> Maybe a) -> SArray# e -> t a

extract :: (e -> Maybe a) -> SArray# e -> ([a], SArray# e)

extract' :: (t e ~ SArray# e, Linear1 t a) => (e -> Maybe a) -> SArray# e -> (t a, SArray# e)

selects :: Foldable f => f (e -> Maybe a) -> SArray# e -> ([[a]], SArray# e)

selects' :: (Foldable f, t e ~ SArray# e, Linear1 t a) => f (e -> Maybe a) -> SArray# e -> ([t a], SArray# e)

isSubseqOf :: SArray# e -> SArray# e -> Bool

reverse :: SArray# e -> SArray# e

force :: SArray# e -> SArray# e

subsequences :: SArray# e -> [SArray# e]

iterate :: Int -> (e -> e) -> e -> SArray# e

nub :: SArray# e -> SArray# e

nubBy :: Equal e -> SArray# e -> SArray# e

ofoldr :: (Int -> e -> b -> b) -> b -> SArray# e -> b

ofoldl :: (Int -> b -> e -> b) -> b -> SArray# e -> b

ofoldr' :: (Int -> e -> b -> b) -> b -> SArray# e -> b

ofoldl' :: (Int -> b -> e -> b) -> b -> SArray# e -> b

o_foldr :: (e -> b -> b) -> b -> SArray# e -> b

o_foldl :: (b -> e -> b) -> b -> SArray# e -> b

o_foldr' :: (e -> b -> b) -> b -> SArray# e -> b

o_foldl' :: (b -> e -> b) -> b -> SArray# e -> b

Bordered (SArray# e) Int

Defined in SDP.Prim.SArray

Methods

bounds :: SArray# e -> (Int, Int)

lower :: SArray# e -> Int

upper :: SArray# e -> Int

sizeOf :: SArray# e -> Int

sizesOf :: SArray# e -> [Int]

indexIn :: SArray# e -> Int -> Bool

indices :: SArray# e -> [Int]

indexOf :: SArray# e -> Int -> Int

offsetOf :: SArray# e -> Int -> Int

Ord e => Set (SArray# e) e

Defined in SDP.Prim.SArray

Methods

set :: SArray# e -> SArray# e

insert :: e -> SArray# e -> SArray# e

delete :: e -> SArray# e -> SArray# e

(/\) :: SArray# e -> SArray# e -> SArray# e

(\/) :: SArray# e -> SArray# e -> SArray# e

(\\) :: SArray# e -> SArray# e -> SArray# e

(\^/) :: SArray# e -> SArray# e -> SArray# e

(/?\) :: SArray# e -> SArray# e -> Bool

(\?/) :: SArray# e -> SArray# e -> Bool

(\+/) :: SArray# e -> SArray# e -> Bool

intersections :: Foldable f => f (SArray# e) -> SArray# e

unions :: Foldable f => f (SArray# e) -> SArray# e

differences :: Foldable f => f (SArray# e) -> SArray# e

symdiffs :: Foldable f => f (SArray# e) -> SArray# e

member :: e -> SArray# e -> Bool

lookupLT :: e -> SArray# e -> Maybe e

lookupGT :: e -> SArray# e -> Maybe e

lookupLE :: e -> SArray# e -> Maybe e

lookupGE :: e -> SArray# e -> Maybe e

SetWith (SArray# e) e

Defined in SDP.Prim.SArray

Methods

setWith :: Compare e -> SArray# e -> SArray# e

groupSetWith :: Compare e -> (e -> e -> e) -> SArray# e -> SArray# e

insertWith :: Compare e -> e -> SArray# e -> SArray# e

deleteWith :: Compare e -> e -> SArray# e -> SArray# e

intersectionWith :: Compare e -> SArray# e -> SArray# e -> SArray# e

differenceWith :: Compare e -> SArray# e -> SArray# e -> SArray# e

symdiffWith :: Compare e -> SArray# e -> SArray# e -> SArray# e

unionWith :: Compare e -> SArray# e -> SArray# e -> SArray# e

intersectionsWith :: Foldable f => Compare e -> f (SArray# e) -> SArray# e

differencesWith :: Foldable f => Compare e -> f (SArray# e) -> SArray# e

unionsWith :: Foldable f => Compare e -> f (SArray# e) -> SArray# e

symdiffsWith :: Foldable f => Compare e -> f (SArray# e) -> SArray# e

isIntersectsWith :: Compare e -> SArray# e -> SArray# e -> Bool

isDisjointWith :: Compare e -> SArray# e -> SArray# e -> Bool

memberWith :: Compare e -> e -> SArray# e -> Bool

isSubsetWith :: Compare e -> SArray# e -> SArray# e -> Bool

subsets :: SArray# e -> [SArray# e]

lookupLTWith :: Compare e -> e -> SArray# e -> Maybe e

lookupGTWith :: Compare e -> e -> SArray# e -> Maybe e

lookupGEWith :: Compare e -> e -> SArray# e -> Maybe e

lookupLEWith :: Compare e -> e -> SArray# e -> Maybe e

Scan (SArray# e) e

Defined in SDP.Prim.SArray

Methods

scanl :: (b -> e -> b) -> b -> SArray# e -> [b]

scanl' :: (b -> e -> b) -> b -> SArray# e -> [b]

scanr :: (e -> b -> b) -> b -> SArray# e -> [b]

scanr' :: (e -> b -> b) -> b -> SArray# e -> [b]

scanl1 :: (e -> e -> e) -> SArray# e -> [e]

scanr1 :: (e -> e -> e) -> SArray# e -> [e]

Map (SArray# e) Int e

Defined in SDP.Prim.SArray

Methods

assocs :: SArray# e -> [(Int, e)]

toMap :: [(Int, e)] -> SArray# e

toMap' :: e -> [(Int, e)] -> SArray# e

insert' :: Int -> e -> SArray# e -> SArray# e

delete' :: Int -> SArray# e -> SArray# e

member' :: Int -> SArray# e -> Bool

(//) :: SArray# e -> [(Int, e)] -> SArray# e

(.!) :: SArray# e -> Int -> e

(!) :: SArray# e -> Int -> e

(!?) :: SArray# e -> Int -> Maybe e

filter' :: (Int -> e -> Bool) -> SArray# e -> SArray# e

union' :: (e -> e -> e) -> SArray# e -> SArray# e -> SArray# e

difference' :: (e -> e -> Maybe e) -> SArray# e -> SArray# e -> SArray# e

intersection' :: (e -> e -> e) -> SArray# e -> SArray# e -> SArray# e

update :: SArray# e -> (Int -> e -> e) -> SArray# e

lookupLT' :: Int -> SArray# e -> Maybe (Int, e)

lookupGT' :: Int -> SArray# e -> Maybe (Int, e)

lookupLE' :: Int -> SArray# e -> Maybe (Int, e)

lookupGE' :: Int -> SArray# e -> Maybe (Int, e)

keys :: SArray# e -> [Int]

(.$) :: (e -> Bool) -> SArray# e -> Maybe Int

(*$) :: (e -> Bool) -> SArray# e -> [Int]

kfoldr :: (Int -> e -> b -> b) -> b -> SArray# e -> b

kfoldl :: (Int -> b -> e -> b) -> b -> SArray# e -> b

kfoldr' :: (Int -> e -> b -> b) -> b -> SArray# e -> b

kfoldl' :: (Int -> b -> e -> b) -> b -> SArray# e -> b

Indexed (SArray# e) Int e

Defined in SDP.Prim.SArray

Methods

assoc :: (Int, Int) -> [(Int, e)] -> SArray# e

assoc' :: (Int, Int) -> e -> [(Int, e)] -> SArray# e

fromIndexed :: Indexed m j e => m -> SArray# e

write' :: SArray# e -> Int -> e -> SArray# e

accum :: (e -> e' -> e) -> SArray# e -> [(Int, e')] -> SArray# e

imap :: Map m j e => (Int, Int) -> m -> (Int -> j) -> SArray# e

update' :: SArray# e -> (e -> e) -> Int -> SArray# e

updates' :: SArray# e -> (Int -> e -> e) -> SArray# 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)

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

Defined in SDP.Prim.SArray

Methods

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

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

type Item (SArray# e)

Defined in SDP.Prim.SArray

type Item (SArray# e) = e

Safe (copy) unpack

fromSArray# :: SArray# e -> Array# e

fromSArray# returns new Array# (uses cloneArray#).

fromSTArray# :: STArray# s e -> State# s -> (# State# s, MutableArray# s e #)

fromSTArray# returns new MutableArray#.

Unsafe unpack

unpackSArray# :: SArray# e -> Array# e

unpackSArray# returns MutableArray# field of SArray#.

offsetSArray# :: SArray# e -> Int#

offsetSArray# returns SArray# offset in elements.

unpackSTArray# :: STArray# s e -> MutableArray# s e

unpackSTArray# returns MutableArray# field of STArray# or fails.

offsetSTArray# :: STArray# s e -> Int#

offsetSTArray# returns STArray# offset in elements.

Unsafe pack

packSArray# :: Int -> Array# e -> SArray# e

packSArray# creates new SArray# from sized Array#.

packSTArray# :: Int -> MutableArray# s e -> STArray# s e

packSTArray# creates new STArray# from sized MutableArray#.

Coerce

coerceSArray# :: Coercible a b => SArray# a -> SArray# b

coerceSArray# is coerce alias.

coerceSTArray# :: Coercible a b => STArray# s a -> STArray# s b

coerceSTArray# is coerce alias.