foundation-0.0.15: Alternative prelude with batteries and no dependencies

LicenseBSD-style
MaintainerVincent Hanquez <vincent@snarc.org>
Stabilityexperimental
Portabilityportable
Safe HaskellNone
LanguageHaskell2010

Foundation.Array

Description

Simple Array and Almost-Array-like data structure

Generally accessible in o(1)

Synopsis

Documentation

data Array a :: * -> * #

Array of a

Instances

Functor Array 

Methods

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

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

Mappable Array # 

Methods

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

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

mapM :: (Applicative m, Monad m) => (a -> m b) -> Array a -> m (Array b) #

sequence :: (Applicative m, Monad m) => Array (m a) -> m (Array a) #

IsList (Array ty) 

Associated Types

type Item (Array ty) :: * #

Methods

fromList :: [Item (Array ty)] -> Array ty #

fromListN :: Int -> [Item (Array ty)] -> Array ty #

toList :: Array ty -> [Item (Array ty)] #

Eq a => Eq (Array a) 

Methods

(==) :: Array a -> Array a -> Bool #

(/=) :: Array a -> Array a -> Bool #

Data ty => Data (Array ty) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Array ty -> c (Array ty) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Array ty) #

toConstr :: Array ty -> Constr #

dataTypeOf :: Array ty -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Array ty)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array ty)) #

gmapT :: (forall b. Data b => b -> b) -> Array ty -> Array ty #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Array ty -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Array ty -> r #

gmapQ :: (forall d. Data d => d -> u) -> Array ty -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Array ty -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Array ty -> m (Array ty) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Array ty -> m (Array ty) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Array ty -> m (Array ty) #

Ord a => Ord (Array a) 

Methods

compare :: Array a -> Array a -> Ordering #

(<) :: Array a -> Array a -> Bool #

(<=) :: Array a -> Array a -> Bool #

(>) :: Array a -> Array a -> Bool #

(>=) :: Array a -> Array a -> Bool #

max :: Array a -> Array a -> Array a #

min :: Array a -> Array a -> Array a #

Show a => Show (Array a) 

Methods

showsPrec :: Int -> Array a -> ShowS #

show :: Array a -> String #

showList :: [Array a] -> ShowS #

Monoid (Array a) 

Methods

mempty :: Array a #

mappend :: Array a -> Array a -> Array a #

mconcat :: [Array a] -> Array a #

NormalForm a => NormalForm (Array a) 

Methods

toNormalForm :: Array a -> () #

Fold1able (Array ty) # 

Methods

foldl1' :: (Element (Array ty) -> Element (Array ty) -> Element (Array ty)) -> NonEmpty (Array ty) -> Element (Array ty) #

foldr1 :: (Element (Array ty) -> Element (Array ty) -> Element (Array ty)) -> NonEmpty (Array ty) -> Element (Array ty) #

Foldable (Array ty) # 

Methods

foldl' :: (a -> Element (Array ty) -> a) -> a -> Array ty -> a #

foldr :: (Element (Array ty) -> a -> a) -> a -> Array ty -> a #

foldr' :: (Element (Array ty) -> a -> a) -> a -> Array ty -> a #

IndexedCollection (Array ty) # 

Methods

(!) :: Array ty -> Offset (Element (Array ty)) -> Maybe (Element (Array ty)) #

findIndex :: (Element (Array ty) -> Bool) -> Array ty -> Maybe (Offset (Element (Array ty))) #

InnerFunctor (Array ty) # 

Methods

imap :: (Element (Array ty) -> Element (Array ty)) -> Array ty -> Array ty #

Copy (Array ty) # 

Methods

copy :: Array ty -> Array ty #

Collection (Array ty) # 

Methods

null :: Array ty -> Bool #

length :: Array ty -> CountOf (Element (Array ty)) #

elem :: (Eq a, (* ~ a) (Element (Array ty))) => Element (Array ty) -> Array ty -> Bool #

notElem :: (Eq a, (* ~ a) (Element (Array ty))) => Element (Array ty) -> Array ty -> Bool #

maximum :: (Ord a, (* ~ a) (Element (Array ty))) => NonEmpty (Array ty) -> Element (Array ty) #

minimum :: (Ord a, (* ~ a) (Element (Array ty))) => NonEmpty (Array ty) -> Element (Array ty) #

any :: (Element (Array ty) -> Bool) -> Array ty -> Bool #

all :: (Element (Array ty) -> Bool) -> Array ty -> Bool #

Sequential (Array ty) # 

Methods

take :: CountOf (Element (Array ty)) -> Array ty -> Array ty #

revTake :: CountOf (Element (Array ty)) -> Array ty -> Array ty #

drop :: CountOf (Element (Array ty)) -> Array ty -> Array ty #

revDrop :: CountOf (Element (Array ty)) -> Array ty -> Array ty #

splitAt :: CountOf (Element (Array ty)) -> Array ty -> (Array ty, Array ty) #

revSplitAt :: CountOf (Element (Array ty)) -> Array ty -> (Array ty, Array ty) #

splitOn :: (Element (Array ty) -> Bool) -> Array ty -> [Array ty] #

break :: (Element (Array ty) -> Bool) -> Array ty -> (Array ty, Array ty) #

breakEnd :: (Element (Array ty) -> Bool) -> Array ty -> (Array ty, Array ty) #

breakElem :: Element (Array ty) -> Array ty -> (Array ty, Array ty) #

takeWhile :: (Element (Array ty) -> Bool) -> Array ty -> Array ty #

dropWhile :: (Element (Array ty) -> Bool) -> Array ty -> Array ty #

intersperse :: Element (Array ty) -> Array ty -> Array ty #

intercalate :: Element (Array ty) -> Array ty -> Element (Array ty) #

span :: (Element (Array ty) -> Bool) -> Array ty -> (Array ty, Array ty) #

spanEnd :: (Element (Array ty) -> Bool) -> Array ty -> (Array ty, Array ty) #

filter :: (Element (Array ty) -> Bool) -> Array ty -> Array ty #

partition :: (Element (Array ty) -> Bool) -> Array ty -> (Array ty, Array ty) #

reverse :: Array ty -> Array ty #

uncons :: Array ty -> Maybe (Element (Array ty), Array ty) #

unsnoc :: Array ty -> Maybe (Array ty, Element (Array ty)) #

snoc :: Array ty -> Element (Array ty) -> Array ty #

cons :: Element (Array ty) -> Array ty -> Array ty #

find :: (Element (Array ty) -> Bool) -> Array ty -> Maybe (Element (Array ty)) #

sortBy :: (Element (Array ty) -> Element (Array ty) -> Ordering) -> Array ty -> Array ty #

singleton :: Element (Array ty) -> Array ty #

head :: NonEmpty (Array ty) -> Element (Array ty) #

last :: NonEmpty (Array ty) -> Element (Array ty) #

tail :: NonEmpty (Array ty) -> Array ty #

init :: NonEmpty (Array ty) -> Array ty #

replicate :: CountOf (Element (Array ty)) -> Element (Array ty) -> Array ty #

isPrefixOf :: Array ty -> Array ty -> Bool #

isSuffixOf :: Array ty -> Array ty -> Bool #

isInfixOf :: Array ty -> Array ty -> Bool #

stripPrefix :: Array ty -> Array ty -> Maybe (Array ty) #

stripSuffix :: Array ty -> Array ty -> Maybe (Array ty) #

BoxedZippable (Array ty) # 

Methods

zip :: (Sequential a, Sequential b, (* ~ Element (Array ty)) (Element a, Element b)) => a -> b -> Array ty #

zip3 :: (Sequential a, Sequential b, Sequential c, (* ~ Element (Array ty)) (Element a, Element b, Element c)) => a -> b -> c -> Array ty #

zip4 :: (Sequential a, Sequential b, Sequential c, Sequential d, (* ~ Element (Array ty)) (Element a, Element b, Element c, Element d)) => a -> b -> c -> d -> Array ty #

zip5 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, (* ~ Element (Array ty)) (Element a, Element b, Element c, Element d, Element e)) => a -> b -> c -> d -> e -> Array ty #

zip6 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f, (* ~ Element (Array ty)) (Element a, Element b, Element c, Element d, Element e, Element f)) => a -> b -> c -> d -> e -> f -> Array ty #

zip7 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f, Sequential g, (* ~ Element (Array ty)) (Element a, Element b, Element c, Element d, Element e, Element f, Element g)) => a -> b -> c -> d -> e -> f -> g -> Array ty #

unzip :: (Sequential a, Sequential b, (* ~ Element (Array ty)) (Element a, Element b)) => Array ty -> (a, b) #

unzip3 :: (Sequential a, Sequential b, Sequential c, (* ~ Element (Array ty)) (Element a, Element b, Element c)) => Array ty -> (a, b, c) #

unzip4 :: (Sequential a, Sequential b, Sequential c, Sequential d, (* ~ Element (Array ty)) (Element a, Element b, Element c, Element d)) => Array ty -> (a, b, c, d) #

unzip5 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, (* ~ Element (Array ty)) (Element a, Element b, Element c, Element d, Element e)) => Array ty -> (a, b, c, d, e) #

unzip6 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f, (* ~ Element (Array ty)) (Element a, Element b, Element c, Element d, Element e, Element f)) => Array ty -> (a, b, c, d, e, f) #

unzip7 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f, Sequential g, (* ~ Element (Array ty)) (Element a, Element b, Element c, Element d, Element e, Element f, Element g)) => Array ty -> (a, b, c, d, e, f, g) #

Zippable (Array ty) # 

Methods

zipWith :: (Sequential a, Sequential b) => (Element a -> Element b -> Element (Array ty)) -> a -> b -> Array ty #

zipWith3 :: (Sequential a, Sequential b, Sequential c) => (Element a -> Element b -> Element c -> Element (Array ty)) -> a -> b -> c -> Array ty #

zipWith4 :: (Sequential a, Sequential b, Sequential c, Sequential d) => (Element a -> Element b -> Element c -> Element d -> Element (Array ty)) -> a -> b -> c -> d -> Array ty #

zipWith5 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e) => (Element a -> Element b -> Element c -> Element d -> Element e -> Element (Array ty)) -> a -> b -> c -> d -> e -> Array ty #

zipWith6 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f) => (Element a -> Element b -> Element c -> Element d -> Element e -> Element f -> Element (Array ty)) -> a -> b -> c -> d -> e -> f -> Array ty #

zipWith7 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f, Sequential g) => (Element a -> Element b -> Element c -> Element d -> Element e -> Element f -> Element g -> Element (Array ty)) -> a -> b -> c -> d -> e -> f -> g -> Array ty #

Buildable (Array ty) # 

Associated Types

type Mutable (Array ty) :: * -> * #

type Step (Array ty) :: * #

Methods

append :: PrimMonad prim => Element (Array ty) -> Builder (Array ty) (Mutable (Array ty)) (Step (Array ty)) prim err () #

build :: PrimMonad prim => Int -> Builder (Array ty) (Mutable (Array ty)) (Step (Array ty)) prim err () -> prim (Either err (Array ty)) #

type Item (Array ty) 
type Item (Array ty) = ty
type Element (Array ty) # 
type Element (Array ty) = ty
type Mutable (Array ty) # 
type Mutable (Array ty) = MArray ty
type Step (Array ty) # 
type Step (Array ty) = ty

data MArray a st :: * -> * -> * #

Mutable Array of a

Instances

MutableCollection (MArray ty) # 

Associated Types

type MutableFreezed (MArray ty :: * -> *) :: * #

type MutableKey (MArray ty :: * -> *) :: * #

type MutableValue (MArray ty :: * -> *) :: * #

Methods

unsafeThaw :: PrimMonad prim => MutableFreezed (MArray ty) -> prim (MArray ty (PrimState prim)) #

unsafeFreeze :: PrimMonad prim => MArray ty (PrimState prim) -> prim (MutableFreezed (MArray ty)) #

thaw :: PrimMonad prim => MutableFreezed (MArray ty) -> prim (MArray ty (PrimState prim)) #

freeze :: PrimMonad prim => MArray ty (PrimState prim) -> prim (MutableFreezed (MArray ty)) #

mutNew :: PrimMonad prim => CountOf (MutableValue (MArray ty)) -> prim (MArray ty (PrimState prim)) #

mutUnsafeWrite :: PrimMonad prim => MArray ty (PrimState prim) -> MutableKey (MArray ty) -> MutableValue (MArray ty) -> prim () #

mutWrite :: PrimMonad prim => MArray ty (PrimState prim) -> MutableKey (MArray ty) -> MutableValue (MArray ty) -> prim () #

mutUnsafeRead :: PrimMonad prim => MArray ty (PrimState prim) -> MutableKey (MArray ty) -> prim (MutableValue (MArray ty)) #

mutRead :: PrimMonad prim => MArray ty (PrimState prim) -> MutableKey (MArray ty) -> prim (MutableValue (MArray ty)) #

type MutableFreezed (MArray ty) # 
type MutableFreezed (MArray ty) = Array ty
type MutableKey (MArray ty) # 
type MutableKey (MArray ty) = Offset ty
type MutableValue (MArray ty) # 
type MutableValue (MArray ty) = ty

data UArray ty :: * -> * #

An array of type built on top of GHC primitive.

The elements need to have fixed sized and the representation is a packed contiguous array in memory that can easily be passed to foreign interface

Instances

PrimType ty => IsList (UArray ty) 

Associated Types

type Item (UArray ty) :: * #

Methods

fromList :: [Item (UArray ty)] -> UArray ty #

fromListN :: Int -> [Item (UArray ty)] -> UArray ty #

toList :: UArray ty -> [Item (UArray ty)] #

(PrimType ty, Eq ty) => Eq (UArray ty) 

Methods

(==) :: UArray ty -> UArray ty -> Bool #

(/=) :: UArray ty -> UArray ty -> Bool #

Data ty => Data (UArray ty) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UArray ty -> c (UArray ty) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UArray ty) #

toConstr :: UArray ty -> Constr #

dataTypeOf :: UArray ty -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (UArray ty)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UArray ty)) #

gmapT :: (forall b. Data b => b -> b) -> UArray ty -> UArray ty #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UArray ty -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UArray ty -> r #

gmapQ :: (forall d. Data d => d -> u) -> UArray ty -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UArray ty -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UArray ty -> m (UArray ty) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UArray ty -> m (UArray ty) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UArray ty -> m (UArray ty) #

(PrimType ty, Ord ty) => Ord (UArray ty) 

Methods

compare :: UArray ty -> UArray ty -> Ordering #

(<) :: UArray ty -> UArray ty -> Bool #

(<=) :: UArray ty -> UArray ty -> Bool #

(>) :: UArray ty -> UArray ty -> Bool #

(>=) :: UArray ty -> UArray ty -> Bool #

max :: UArray ty -> UArray ty -> UArray ty #

min :: UArray ty -> UArray ty -> UArray ty #

(PrimType ty, Show ty) => Show (UArray ty) 

Methods

showsPrec :: Int -> UArray ty -> ShowS #

show :: UArray ty -> String #

showList :: [UArray ty] -> ShowS #

PrimType ty => Monoid (UArray ty) 

Methods

mempty :: UArray ty #

mappend :: UArray ty -> UArray ty -> UArray ty #

mconcat :: [UArray ty] -> UArray ty #

NormalForm (UArray ty) 

Methods

toNormalForm :: UArray ty -> () #

PrimType ty => Fold1able (UArray ty) # 

Methods

foldl1' :: (Element (UArray ty) -> Element (UArray ty) -> Element (UArray ty)) -> NonEmpty (UArray ty) -> Element (UArray ty) #

foldr1 :: (Element (UArray ty) -> Element (UArray ty) -> Element (UArray ty)) -> NonEmpty (UArray ty) -> Element (UArray ty) #

PrimType ty => Foldable (UArray ty) # 

Methods

foldl' :: (a -> Element (UArray ty) -> a) -> a -> UArray ty -> a #

foldr :: (Element (UArray ty) -> a -> a) -> a -> UArray ty -> a #

foldr' :: (Element (UArray ty) -> a -> a) -> a -> UArray ty -> a #

PrimType ty => IndexedCollection (UArray ty) # 

Methods

(!) :: UArray ty -> Offset (Element (UArray ty)) -> Maybe (Element (UArray ty)) #

findIndex :: (Element (UArray ty) -> Bool) -> UArray ty -> Maybe (Offset (Element (UArray ty))) #

PrimType ty => InnerFunctor (UArray ty) # 

Methods

imap :: (Element (UArray ty) -> Element (UArray ty)) -> UArray ty -> UArray ty #

PrimType ty => Copy (UArray ty) # 

Methods

copy :: UArray ty -> UArray ty #

PrimType ty => Collection (UArray ty) # 

Methods

null :: UArray ty -> Bool #

length :: UArray ty -> CountOf (Element (UArray ty)) #

elem :: (Eq a, (* ~ a) (Element (UArray ty))) => Element (UArray ty) -> UArray ty -> Bool #

notElem :: (Eq a, (* ~ a) (Element (UArray ty))) => Element (UArray ty) -> UArray ty -> Bool #

maximum :: (Ord a, (* ~ a) (Element (UArray ty))) => NonEmpty (UArray ty) -> Element (UArray ty) #

minimum :: (Ord a, (* ~ a) (Element (UArray ty))) => NonEmpty (UArray ty) -> Element (UArray ty) #

any :: (Element (UArray ty) -> Bool) -> UArray ty -> Bool #

all :: (Element (UArray ty) -> Bool) -> UArray ty -> Bool #

PrimType ty => Sequential (UArray ty) # 

Methods

take :: CountOf (Element (UArray ty)) -> UArray ty -> UArray ty #

revTake :: CountOf (Element (UArray ty)) -> UArray ty -> UArray ty #

drop :: CountOf (Element (UArray ty)) -> UArray ty -> UArray ty #

revDrop :: CountOf (Element (UArray ty)) -> UArray ty -> UArray ty #

splitAt :: CountOf (Element (UArray ty)) -> UArray ty -> (UArray ty, UArray ty) #

revSplitAt :: CountOf (Element (UArray ty)) -> UArray ty -> (UArray ty, UArray ty) #

splitOn :: (Element (UArray ty) -> Bool) -> UArray ty -> [UArray ty] #

break :: (Element (UArray ty) -> Bool) -> UArray ty -> (UArray ty, UArray ty) #

breakEnd :: (Element (UArray ty) -> Bool) -> UArray ty -> (UArray ty, UArray ty) #

breakElem :: Element (UArray ty) -> UArray ty -> (UArray ty, UArray ty) #

takeWhile :: (Element (UArray ty) -> Bool) -> UArray ty -> UArray ty #

dropWhile :: (Element (UArray ty) -> Bool) -> UArray ty -> UArray ty #

intersperse :: Element (UArray ty) -> UArray ty -> UArray ty #

intercalate :: Element (UArray ty) -> UArray ty -> Element (UArray ty) #

span :: (Element (UArray ty) -> Bool) -> UArray ty -> (UArray ty, UArray ty) #

spanEnd :: (Element (UArray ty) -> Bool) -> UArray ty -> (UArray ty, UArray ty) #

filter :: (Element (UArray ty) -> Bool) -> UArray ty -> UArray ty #

partition :: (Element (UArray ty) -> Bool) -> UArray ty -> (UArray ty, UArray ty) #

reverse :: UArray ty -> UArray ty #

uncons :: UArray ty -> Maybe (Element (UArray ty), UArray ty) #

unsnoc :: UArray ty -> Maybe (UArray ty, Element (UArray ty)) #

snoc :: UArray ty -> Element (UArray ty) -> UArray ty #

cons :: Element (UArray ty) -> UArray ty -> UArray ty #

find :: (Element (UArray ty) -> Bool) -> UArray ty -> Maybe (Element (UArray ty)) #

sortBy :: (Element (UArray ty) -> Element (UArray ty) -> Ordering) -> UArray ty -> UArray ty #

singleton :: Element (UArray ty) -> UArray ty #

head :: NonEmpty (UArray ty) -> Element (UArray ty) #

last :: NonEmpty (UArray ty) -> Element (UArray ty) #

tail :: NonEmpty (UArray ty) -> UArray ty #

init :: NonEmpty (UArray ty) -> UArray ty #

replicate :: CountOf (Element (UArray ty)) -> Element (UArray ty) -> UArray ty #

isPrefixOf :: UArray ty -> UArray ty -> Bool #

isSuffixOf :: UArray ty -> UArray ty -> Bool #

isInfixOf :: UArray ty -> UArray ty -> Bool #

stripPrefix :: UArray ty -> UArray ty -> Maybe (UArray ty) #

stripSuffix :: UArray ty -> UArray ty -> Maybe (UArray ty) #

PrimType ty => Zippable (UArray ty) # 

Methods

zipWith :: (Sequential a, Sequential b) => (Element a -> Element b -> Element (UArray ty)) -> a -> b -> UArray ty #

zipWith3 :: (Sequential a, Sequential b, Sequential c) => (Element a -> Element b -> Element c -> Element (UArray ty)) -> a -> b -> c -> UArray ty #

zipWith4 :: (Sequential a, Sequential b, Sequential c, Sequential d) => (Element a -> Element b -> Element c -> Element d -> Element (UArray ty)) -> a -> b -> c -> d -> UArray ty #

zipWith5 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e) => (Element a -> Element b -> Element c -> Element d -> Element e -> Element (UArray ty)) -> a -> b -> c -> d -> e -> UArray ty #

zipWith6 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f) => (Element a -> Element b -> Element c -> Element d -> Element e -> Element f -> Element (UArray ty)) -> a -> b -> c -> d -> e -> f -> UArray ty #

zipWith7 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f, Sequential g) => (Element a -> Element b -> Element c -> Element d -> Element e -> Element f -> Element g -> Element (UArray ty)) -> a -> b -> c -> d -> e -> f -> g -> UArray ty #

PrimType ty => Buildable (UArray ty) # 

Associated Types

type Mutable (UArray ty) :: * -> * #

type Step (UArray ty) :: * #

Methods

append :: PrimMonad prim => Element (UArray ty) -> Builder (UArray ty) (Mutable (UArray ty)) (Step (UArray ty)) prim err () #

build :: PrimMonad prim => Int -> Builder (UArray ty) (Mutable (UArray ty)) (Step (UArray ty)) prim err () -> prim (Either err (UArray ty)) #

PrimType a => Hashable (UArray a) # 

Methods

hashMix :: Hasher st => UArray a -> st -> st #

type Item (UArray ty) 
type Item (UArray ty) = ty
type Element (UArray ty) # 
type Element (UArray ty) = ty
type Mutable (UArray ty) # 
type Mutable (UArray ty) = MUArray ty
type Step (UArray ty) # 
type Step (UArray ty) = ty

data MUArray ty st :: * -> * -> * #

A Mutable array of types built on top of GHC primitive.

Element in this array can be modified in place.

Instances

PrimType ty => MutableCollection (MUArray ty) # 

Associated Types

type MutableFreezed (MUArray ty :: * -> *) :: * #

type MutableKey (MUArray ty :: * -> *) :: * #

type MutableValue (MUArray ty :: * -> *) :: * #

Methods

unsafeThaw :: PrimMonad prim => MutableFreezed (MUArray ty) -> prim (MUArray ty (PrimState prim)) #

unsafeFreeze :: PrimMonad prim => MUArray ty (PrimState prim) -> prim (MutableFreezed (MUArray ty)) #

thaw :: PrimMonad prim => MutableFreezed (MUArray ty) -> prim (MUArray ty (PrimState prim)) #

freeze :: PrimMonad prim => MUArray ty (PrimState prim) -> prim (MutableFreezed (MUArray ty)) #

mutNew :: PrimMonad prim => CountOf (MutableValue (MUArray ty)) -> prim (MUArray ty (PrimState prim)) #

mutUnsafeWrite :: PrimMonad prim => MUArray ty (PrimState prim) -> MutableKey (MUArray ty) -> MutableValue (MUArray ty) -> prim () #

mutWrite :: PrimMonad prim => MUArray ty (PrimState prim) -> MutableKey (MUArray ty) -> MutableValue (MUArray ty) -> prim () #

mutUnsafeRead :: PrimMonad prim => MUArray ty (PrimState prim) -> MutableKey (MUArray ty) -> prim (MutableValue (MUArray ty)) #

mutRead :: PrimMonad prim => MUArray ty (PrimState prim) -> MutableKey (MUArray ty) -> prim (MutableValue (MUArray ty)) #

type MutableFreezed (MUArray ty) # 
type MutableKey (MUArray ty) # 
type MutableKey (MUArray ty) = Offset ty
type MutableValue (MUArray ty) # 
type MutableValue (MUArray ty) = ty

data ChunkedUArray ty #

Instances

PrimType ty => IsList (ChunkedUArray ty) # 

Associated Types

type Item (ChunkedUArray ty) :: * #

PrimType ty => Eq (ChunkedUArray ty) # 
(Ord ty, PrimType ty) => Ord (ChunkedUArray ty) # 
(Show ty, PrimType ty) => Show (ChunkedUArray ty) # 
Monoid (ChunkedUArray a) # 
NormalForm (ChunkedUArray ty) # 

Methods

toNormalForm :: ChunkedUArray ty -> () #

PrimType ty => Foldable (ChunkedUArray ty) # 

Methods

foldl' :: (a -> Element (ChunkedUArray ty) -> a) -> a -> ChunkedUArray ty -> a #

foldr :: (Element (ChunkedUArray ty) -> a -> a) -> a -> ChunkedUArray ty -> a #

foldr' :: (Element (ChunkedUArray ty) -> a -> a) -> a -> ChunkedUArray ty -> a #

PrimType ty => IndexedCollection (ChunkedUArray ty) # 
PrimType ty => Collection (ChunkedUArray ty) # 
PrimType ty => Sequential (ChunkedUArray ty) # 

Methods

take :: CountOf (Element (ChunkedUArray ty)) -> ChunkedUArray ty -> ChunkedUArray ty #

revTake :: CountOf (Element (ChunkedUArray ty)) -> ChunkedUArray ty -> ChunkedUArray ty #

drop :: CountOf (Element (ChunkedUArray ty)) -> ChunkedUArray ty -> ChunkedUArray ty #

revDrop :: CountOf (Element (ChunkedUArray ty)) -> ChunkedUArray ty -> ChunkedUArray ty #

splitAt :: CountOf (Element (ChunkedUArray ty)) -> ChunkedUArray ty -> (ChunkedUArray ty, ChunkedUArray ty) #

revSplitAt :: CountOf (Element (ChunkedUArray ty)) -> ChunkedUArray ty -> (ChunkedUArray ty, ChunkedUArray ty) #

splitOn :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> [ChunkedUArray ty] #

break :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> (ChunkedUArray ty, ChunkedUArray ty) #

breakEnd :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> (ChunkedUArray ty, ChunkedUArray ty) #

breakElem :: Element (ChunkedUArray ty) -> ChunkedUArray ty -> (ChunkedUArray ty, ChunkedUArray ty) #

takeWhile :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> ChunkedUArray ty #

dropWhile :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> ChunkedUArray ty #

intersperse :: Element (ChunkedUArray ty) -> ChunkedUArray ty -> ChunkedUArray ty #

intercalate :: Element (ChunkedUArray ty) -> ChunkedUArray ty -> Element (ChunkedUArray ty) #

span :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> (ChunkedUArray ty, ChunkedUArray ty) #

spanEnd :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> (ChunkedUArray ty, ChunkedUArray ty) #

filter :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> ChunkedUArray ty #

partition :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> (ChunkedUArray ty, ChunkedUArray ty) #

reverse :: ChunkedUArray ty -> ChunkedUArray ty #

uncons :: ChunkedUArray ty -> Maybe (Element (ChunkedUArray ty), ChunkedUArray ty) #

unsnoc :: ChunkedUArray ty -> Maybe (ChunkedUArray ty, Element (ChunkedUArray ty)) #

snoc :: ChunkedUArray ty -> Element (ChunkedUArray ty) -> ChunkedUArray ty #

cons :: Element (ChunkedUArray ty) -> ChunkedUArray ty -> ChunkedUArray ty #

find :: (Element (ChunkedUArray ty) -> Bool) -> ChunkedUArray ty -> Maybe (Element (ChunkedUArray ty)) #

sortBy :: (Element (ChunkedUArray ty) -> Element (ChunkedUArray ty) -> Ordering) -> ChunkedUArray ty -> ChunkedUArray ty #

singleton :: Element (ChunkedUArray ty) -> ChunkedUArray ty #

head :: NonEmpty (ChunkedUArray ty) -> Element (ChunkedUArray ty) #

last :: NonEmpty (ChunkedUArray ty) -> Element (ChunkedUArray ty) #

tail :: NonEmpty (ChunkedUArray ty) -> ChunkedUArray ty #

init :: NonEmpty (ChunkedUArray ty) -> ChunkedUArray ty #

replicate :: CountOf (Element (ChunkedUArray ty)) -> Element (ChunkedUArray ty) -> ChunkedUArray ty #

isPrefixOf :: ChunkedUArray ty -> ChunkedUArray ty -> Bool #

isSuffixOf :: ChunkedUArray ty -> ChunkedUArray ty -> Bool #

isInfixOf :: ChunkedUArray ty -> ChunkedUArray ty -> Bool #

stripPrefix :: ChunkedUArray ty -> ChunkedUArray ty -> Maybe (ChunkedUArray ty) #

stripSuffix :: ChunkedUArray ty -> ChunkedUArray ty -> Maybe (ChunkedUArray ty) #

type Item (ChunkedUArray ty) # 
type Item (ChunkedUArray ty) = ty
type Element (ChunkedUArray ty) # 
type Element (ChunkedUArray ty) = ty

data Bitmap #

Instances

IsList Bitmap # 

Associated Types

type Item Bitmap :: * #

Eq Bitmap # 

Methods

(==) :: Bitmap -> Bitmap -> Bool #

(/=) :: Bitmap -> Bitmap -> Bool #

Ord Bitmap # 
Show Bitmap # 
Monoid Bitmap # 
Foldable Bitmap # 

Methods

foldl' :: (a -> Element Bitmap -> a) -> a -> Bitmap -> a #

foldr :: (Element Bitmap -> a -> a) -> a -> Bitmap -> a #

foldr' :: (Element Bitmap -> a -> a) -> a -> Bitmap -> a #

IndexedCollection Bitmap # 
InnerFunctor Bitmap # 
Collection Bitmap # 
Sequential Bitmap # 

Methods

take :: CountOf (Element Bitmap) -> Bitmap -> Bitmap #

revTake :: CountOf (Element Bitmap) -> Bitmap -> Bitmap #

drop :: CountOf (Element Bitmap) -> Bitmap -> Bitmap #

revDrop :: CountOf (Element Bitmap) -> Bitmap -> Bitmap #

splitAt :: CountOf (Element Bitmap) -> Bitmap -> (Bitmap, Bitmap) #

revSplitAt :: CountOf (Element Bitmap) -> Bitmap -> (Bitmap, Bitmap) #

splitOn :: (Element Bitmap -> Bool) -> Bitmap -> [Bitmap] #

break :: (Element Bitmap -> Bool) -> Bitmap -> (Bitmap, Bitmap) #

breakEnd :: (Element Bitmap -> Bool) -> Bitmap -> (Bitmap, Bitmap) #

breakElem :: Element Bitmap -> Bitmap -> (Bitmap, Bitmap) #

takeWhile :: (Element Bitmap -> Bool) -> Bitmap -> Bitmap #

dropWhile :: (Element Bitmap -> Bool) -> Bitmap -> Bitmap #

intersperse :: Element Bitmap -> Bitmap -> Bitmap #

intercalate :: Element Bitmap -> Bitmap -> Element Bitmap #

span :: (Element Bitmap -> Bool) -> Bitmap -> (Bitmap, Bitmap) #

spanEnd :: (Element Bitmap -> Bool) -> Bitmap -> (Bitmap, Bitmap) #

filter :: (Element Bitmap -> Bool) -> Bitmap -> Bitmap #

partition :: (Element Bitmap -> Bool) -> Bitmap -> (Bitmap, Bitmap) #

reverse :: Bitmap -> Bitmap #

uncons :: Bitmap -> Maybe (Element Bitmap, Bitmap) #

unsnoc :: Bitmap -> Maybe (Bitmap, Element Bitmap) #

snoc :: Bitmap -> Element Bitmap -> Bitmap #

cons :: Element Bitmap -> Bitmap -> Bitmap #

find :: (Element Bitmap -> Bool) -> Bitmap -> Maybe (Element Bitmap) #

sortBy :: (Element Bitmap -> Element Bitmap -> Ordering) -> Bitmap -> Bitmap #

singleton :: Element Bitmap -> Bitmap #

head :: NonEmpty Bitmap -> Element Bitmap #

last :: NonEmpty Bitmap -> Element Bitmap #

tail :: NonEmpty Bitmap -> Bitmap #

init :: NonEmpty Bitmap -> Bitmap #

replicate :: CountOf (Element Bitmap) -> Element Bitmap -> Bitmap #

isPrefixOf :: Bitmap -> Bitmap -> Bool #

isSuffixOf :: Bitmap -> Bitmap -> Bool #

isInfixOf :: Bitmap -> Bitmap -> Bool #

stripPrefix :: Bitmap -> Bitmap -> Maybe Bitmap #

stripSuffix :: Bitmap -> Bitmap -> Maybe Bitmap #

type Item Bitmap # 
type Element Bitmap # 

data MutableBitmap st #

class Eq ty => PrimType ty #

Represent the accessor for types that can be stored in the UArray and MUArray.

Types need to be a instance of storable and have fixed sized.

Instances

PrimType Char 
PrimType Double 
PrimType Float 
PrimType Int 
PrimType Int8 
PrimType Int16 
PrimType Int32 
PrimType Int64 
PrimType Word 
PrimType Word8 
PrimType Word16 
PrimType Word32 
PrimType Word64 
PrimType CChar 
PrimType CUChar 
PrimType Word256 
PrimType Word128 
PrimType Char7 
PrimType Seconds # 
PrimType NanoSeconds # 
PrimType a => PrimType (LE a) 

Methods

primSizeInBytes :: Proxy * (LE a) -> CountOf Word8 #

primShiftToBytes :: Proxy * (LE a) -> Int #

primBaUIndex :: ByteArray# -> Offset (LE a) -> LE a #

primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset (LE a) -> prim (LE a) #

primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset (LE a) -> LE a -> prim () #

primAddrIndex :: Addr# -> Offset (LE a) -> LE a #

primAddrRead :: PrimMonad prim => Addr# -> Offset (LE a) -> prim (LE a) #

primAddrWrite :: PrimMonad prim => Addr# -> Offset (LE a) -> LE a -> prim () #

PrimType a => PrimType (BE a) 

Methods

primSizeInBytes :: Proxy * (BE a) -> CountOf Word8 #

primShiftToBytes :: Proxy * (BE a) -> Int #

primBaUIndex :: ByteArray# -> Offset (BE a) -> BE a #

primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset (BE a) -> prim (BE a) #

primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset (BE a) -> BE a -> prim () #

primAddrIndex :: Addr# -> Offset (BE a) -> BE a #

primAddrRead :: PrimMonad prim => Addr# -> Offset (BE a) -> prim (BE a) #

primAddrWrite :: PrimMonad prim => Addr# -> Offset (BE a) -> BE a -> prim () #

data OutOfBound :: * #

Exception during an operation accessing the vector out of bound

Represent the type of operation, the index accessed, and the total length of the vector.