SDP.Prim.SBytes

SDP.Prim.SBytes provides strict unboxed array pseudo-primitive types SBytes#, STBytes# and IOBytes#.

Exports

module SDP.IndexedM

module SDP.Unboxed

module SDP.SortM

module SDP.Sort

Preudo-primitive types

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

MIOBytes# is mutable pseudo-primitive Int-indexed strict unboxed array.

Constructors

MIOBytes# (STBytes# RealWorld e)

Instances

(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, Unboxed e) => SortM io (MIOBytes# io e) e

Defined in SDP.Prim.SBytes

Methods

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

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

(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, 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 => 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, 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, 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, Unboxed e) => Freeze io (MIOBytes# io e) (SBytes# e)

Defined in SDP.Prim.SBytes

Methods

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

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

Eq (MIOBytes# io e)

Defined in SDP.Prim.SBytes

Methods

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

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

Estimate (MIOBytes# io e)

Defined in SDP.Prim.SBytes

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Bordered (MIOBytes# io e) Int

Defined in SDP.Prim.SBytes

Methods

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

lower :: MIOBytes# io e -> Int

upper :: MIOBytes# io e -> Int

sizeOf :: MIOBytes# io e -> Int

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

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

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

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

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

type IOBytes# = MIOBytes# IO

IOBytes# is mutable pseudo-primitive Int-indexed strict unboxed array.

data STBytes# s e

STBytes# is mutable pseudo-primitive Int-indexed strict unboxed array type.

Instances

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)

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

Defined in SDP.Prim.SBytes

Methods

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

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

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

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

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]

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

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

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

Defined in SDP.Prim.SBytes

Methods

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

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

Eq (STBytes# s e)

Defined in SDP.Prim.SBytes

Methods

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

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

Estimate (STBytes# s e)

Defined in SDP.Prim.SBytes

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Bordered (STBytes# s e) Int

Defined in SDP.Prim.SBytes

Methods

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

lower :: STBytes# s e -> Int

upper :: STBytes# s e -> Int

sizeOf :: STBytes# s e -> Int

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

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

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

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

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

data SBytes# e

SBytes# is immutable pseudo-primitive Int-indexed strict unboxed array type.

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

Instances

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

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

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

Defined in SDP.Prim.SBytes

Methods

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

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

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

Defined in SDP.Prim.SBytes

Methods

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

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

Unboxed e => IsList (SBytes# e)

Defined in SDP.Prim.SBytes

Associated Types

type Item (SBytes# e)

Methods

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

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

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

Unboxed e => Eq (SBytes# e)

Defined in SDP.Prim.SBytes

Methods

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

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

(Unboxed e, Ord e) => Ord (SBytes# e)

Defined in SDP.Prim.SBytes

Methods

compare :: SBytes# e -> SBytes# e -> Ordering

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

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

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

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

max :: SBytes# e -> SBytes# e -> SBytes# e

min :: SBytes# e -> SBytes# e -> SBytes# e

(Unboxed e, Read e) => Read (SBytes# e)

Defined in SDP.Prim.SBytes

Methods

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

readList :: ReadS [SBytes# e]

readPrec :: ReadPrec (SBytes# e)

readListPrec :: ReadPrec [SBytes# e]

(Unboxed e, Show e) => Show (SBytes# e)

Defined in SDP.Prim.SBytes

Methods

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

show :: SBytes# e -> String

showList :: [SBytes# e] -> ShowS

IsString (SBytes# Char)

Defined in SDP.Prim.SBytes

Methods

fromString :: String -> SBytes# Char

Unboxed e => Semigroup (SBytes# e)

Defined in SDP.Prim.SBytes

Methods

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

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

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

Unboxed e => Monoid (SBytes# e)

Defined in SDP.Prim.SBytes

Methods

mempty :: SBytes# e

mappend :: SBytes# e -> SBytes# e -> SBytes# e

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

Default (SBytes# e)

Defined in SDP.Prim.SBytes

Methods

def :: SBytes# e

Estimate (SBytes# e)

Defined in SDP.Prim.SBytes

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Nullable (SBytes# e)

Defined in SDP.Prim.SBytes

Methods

lzero :: SBytes# e

isNull :: SBytes# e -> Bool

Unboxed e => Sort (SBytes# e) e

Defined in SDP.Prim.SBytes

Methods

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

sortBy :: Compare e -> SBytes# e -> SBytes# e

Unboxed e => Sort (Ublist e) e

Defined in SDP.ByteList.Ublist

Methods

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

sortBy :: Compare e -> Ublist e -> Ublist e

Unboxed e => Split (SBytes# e) e

Defined in SDP.Prim.SBytes

Methods

take :: Int -> SBytes# e -> SBytes# e

drop :: Int -> SBytes# e -> SBytes# e

keep :: Int -> SBytes# e -> SBytes# e

sans :: Int -> SBytes# e -> SBytes# e

save :: Int -> SBytes# e -> SBytes# e

skip :: Int -> SBytes# e -> SBytes# e

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

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

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

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

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

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

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

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

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

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

replaceBy :: SBytes# e -> SBytes# e -> SBytes# e -> SBytes# e

removeAll :: SBytes# e -> SBytes# e -> SBytes# e

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

justifyL :: Int -> e -> SBytes# e -> SBytes# e

justifyR :: Int -> e -> SBytes# e -> SBytes# e

each :: Int -> SBytes# e -> SBytes# e

eachFrom :: Int -> Int -> SBytes# e -> SBytes# e

isPrefixOf :: SBytes# e -> SBytes# e -> Bool

isSuffixOf :: SBytes# e -> SBytes# e -> Bool

isInfixOf :: SBytes# e -> SBytes# e -> Bool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Unboxed e => Linear (SBytes# e) e

Defined in SDP.Prim.SBytes

Methods

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

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

toHead :: e -> SBytes# e -> SBytes# e

head :: SBytes# e -> e

tail :: SBytes# e -> SBytes# e

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

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

toLast :: SBytes# e -> e -> SBytes# e

init :: SBytes# e -> SBytes# e

last :: SBytes# e -> e

single :: e -> SBytes# e

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

replicate :: Int -> e -> SBytes# e

fromList :: [e] -> SBytes# e

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

listR :: SBytes# e -> [e]

listL :: SBytes# e -> [e]

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

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

write :: SBytes# e -> Int -> e -> SBytes# e

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

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

intersperse :: e -> SBytes# e -> SBytes# e

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

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

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

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

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

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

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

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

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

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

isSubseqOf :: SBytes# e -> SBytes# e -> Bool

reverse :: SBytes# e -> SBytes# e

force :: SBytes# e -> SBytes# e

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

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

nub :: SBytes# e -> SBytes# e

nubBy :: Equal e -> SBytes# e -> SBytes# e

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

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

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

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

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

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

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

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

Bordered (SBytes# e) Int

Defined in SDP.Prim.SBytes

Methods

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

lower :: SBytes# e -> Int

upper :: SBytes# e -> Int

sizeOf :: SBytes# e -> Int

sizesOf :: SBytes# e -> [Int]

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

indices :: SBytes# e -> [Int]

indexOf :: SBytes# e -> Int -> Int

offsetOf :: SBytes# e -> Int -> Int

(Unboxed e, Ord e) => Set (SBytes# e) e

Defined in SDP.Prim.SBytes

Methods

set :: SBytes# e -> SBytes# e

insert :: e -> SBytes# e -> SBytes# e

delete :: e -> SBytes# e -> SBytes# e

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

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

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

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

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

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

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

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

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

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

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

member :: e -> SBytes# e -> Bool

lookupLT :: e -> SBytes# e -> Maybe e

lookupGT :: e -> SBytes# e -> Maybe e

lookupLE :: e -> SBytes# e -> Maybe e

lookupGE :: e -> SBytes# e -> Maybe e

Unboxed e => SetWith (SBytes# e) e

Defined in SDP.Prim.SBytes

Methods

setWith :: Compare e -> SBytes# e -> SBytes# e

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

insertWith :: Compare e -> e -> SBytes# e -> SBytes# e

deleteWith :: Compare e -> e -> SBytes# e -> SBytes# e

intersectionWith :: Compare e -> SBytes# e -> SBytes# e -> SBytes# e

differenceWith :: Compare e -> SBytes# e -> SBytes# e -> SBytes# e

symdiffWith :: Compare e -> SBytes# e -> SBytes# e -> SBytes# e

unionWith :: Compare e -> SBytes# e -> SBytes# e -> SBytes# e

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

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

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

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

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

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

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

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

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

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

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

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

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

Unboxed e => Scan (SBytes# e) e

Defined in SDP.Prim.SBytes

Methods

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

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

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

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

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

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

Unboxed e => Map (SBytes# e) Int e

Defined in SDP.Prim.SBytes

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

keys :: SBytes# e -> [Int]

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

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

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

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

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

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

Unboxed e => Indexed (SBytes# e) Int e

Defined in SDP.Prim.SBytes

Methods

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

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

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

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

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

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

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

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

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

Defined in SDP.Prim.SBytes

Methods

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

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

type Item (SBytes# e)

Defined in SDP.Prim.SBytes

type Item (SBytes# e) = e

Unpack unboxed arrays

fromSBytes# :: Unboxed e => SBytes# e -> ByteArray#

fromSBytes# returns new ByteArray#.

packSBytes# :: Unboxed e => Int -> ByteArray# -> SBytes# e

packSBytes# creates new SBytes# from sized ByteArray#.

unpackSBytes# :: Unboxed e => SBytes# e -> ByteArray#

unpackSBytes# returns ByteArray# field of SBytes#.

offsetSBytes# :: Unboxed e => SBytes# e -> Int

offsetSBytes# returns SBytes# offset in elements.

fromSTBytes# :: Unboxed e => STBytes# s e -> State# s -> (# State# s, MutableByteArray# s #)

fromSTBytes# returns new MutableByteArray#.

packSTBytes# :: Unboxed e => Int -> MutableByteArray# s -> STBytes# s e

packSTBytes# creates new STBytes# from sized MutableByteArray#.

unpackSTBytes# :: Unboxed e => STBytes# s e -> MutableByteArray# s

unpackSTBytes# returns MutableByteArray# field of STBytes#.

offsetSTBytes# :: Unboxed e => STBytes# s e -> Int#

offsetSTBytes# returns STBytes# offset in bytes.

Coerce unboxed arrays

unsafeCoerceSBytes# :: (Unboxed a, Unboxed b) => SBytes# a -> SBytes# b

unsafeCoerceSBytes# is unsafe low-lowel coerce of an array with recounting the number of elements and offset (with possible rounding).

unsafeCoerceSTBytes# :: (Unboxed a, Unboxed b) => STBytes# s a -> STBytes# s b

unsafeCoerceSTBytes# is unsafe low-lowel coerce of an mutable array with recounting the number of elements and offset (with possible rounding).

Unsafe pointer conversions

unsafeSBytesToPtr# :: Unboxed e => SBytes# e -> IO (Int, Ptr e)

unsafeSBytesToPtr# es byte-wise stores SBytes# content to Ptr. Returns the number of overwritten elements and a pointer to psizeof es (sizeOf es) bytes of allocated memory.

unsafePtrToSBytes# :: Unboxed e => (Int, Ptr e) -> IO (SBytes# e)

unsafePtrToSBytes# n ptr byte-wise stores n elements of Ptr ptr to SBytes#.

Hash

hashSBytesWith# :: Unboxed e => Int -> SBytes# e -> Int

Calculate hash SBytes# using hashUnboxedWith.