Safe Haskell	Unsafe
Language	Haskell2010

Data.CompactSequence.Internal.Array

Synopsis

newtype Array n a = Array (SmallArray a)
singleton :: a -> Array Sz1 a
unsafeSmallArrayToArray :: SmallArray a -> Array n a
arrayToSmallArray :: Array n a -> SmallArray a
getSingleton# :: Array Sz1 a -> (#a#)
getSingletonA :: Applicative f => Array Sz1 a -> f a
splitArray :: Size n -> Array (Twice n) a -> (Array n a, Array n a)
splitSmallArray# :: Int -> SmallArray a -> (#SmallArray# a, SmallArray# a#)
append :: Size n -> Array n a -> Array n a -> Array (Twice n) a
appendSmallArrays :: Int -> SmallArray a -> SmallArray a -> SmallArray a
createSmallArray :: Int -> a -> (forall s. SmallMutableArray s a -> ST s ()) -> SmallArray a
arraySplitListN :: Size n -> [a] -> (Array n a, [a])
smallArraySplitListN :: Int -> [a] -> (SmallArray a, [a])
fromList :: Size n -> [a] -> Array n a

Documentation

newtype Array n a Source #

Constructors

Array (SmallArray a)

Instances

Functor (Array n) Source #
Instance details Defined in Data.CompactSequence.Internal.Array Methods fmap :: (a -> b) -> Array n a -> Array n b # (<$) :: a -> Array n b -> Array n a #
Foldable (Array n) Source #
Instance details Defined in Data.CompactSequence.Internal.Array Methods fold :: Monoid m => Array n m -> m # foldMap :: Monoid m => (a -> m) -> Array n a -> m # foldr :: (a -> b -> b) -> b -> Array n a -> b # foldr' :: (a -> b -> b) -> b -> Array n a -> b # foldl :: (b -> a -> b) -> b -> Array n a -> b # foldl' :: (b -> a -> b) -> b -> Array n a -> b # foldr1 :: (a -> a -> a) -> Array n a -> a # foldl1 :: (a -> a -> a) -> Array n a -> a # toList :: Array n a -> [a] # null :: Array n a -> Bool # length :: Array n a -> Int # elem :: Eq a => a -> Array n a -> Bool # maximum :: Ord a => Array n a -> a # minimum :: Ord a => Array n a -> a # sum :: Num a => Array n a -> a # product :: Num a => Array n a -> a #
Traversable (Array n) Source #
Instance details Defined in Data.CompactSequence.Internal.Array Methods traverse :: Applicative f => (a -> f b) -> Array n a -> f (Array n b) # sequenceA :: Applicative f => Array n (f a) -> f (Array n a) # mapM :: Monad m => (a -> m b) -> Array n a -> m (Array n b) # sequence :: Monad m => Array n (m a) -> m (Array n a) #

singleton :: a -> Array Sz1 a Source #

unsafeSmallArrayToArray :: SmallArray a -> Array n a Source #

Unsafely convert a SmallArray of size n to an Array n. This is genuinely unsafe: if n is greater than the true array size, then some operation will eventually violate memory safety.

arrayToSmallArray :: Array n a -> SmallArray a Source #

getSingleton# :: Array Sz1 a -> (#a#) Source #

getSingletonA :: Applicative f => Array Sz1 a -> f a Source #

splitArray :: Size n -> Array (Twice n) a -> (Array n a, Array n a) Source #

splitSmallArray# :: Int -> SmallArray a -> (#SmallArray# a, SmallArray# a#) Source #

append :: Size n -> Array n a -> Array n a -> Array (Twice n) a Source #

Append two arrays of the same size. We take the size of the argument arrays so we can build the result array before loading the first argument array into cache. Is this the right approach? Not sure. We *certainly* don't want to just use <>, because

appendSmallArrays :: Int -> SmallArray a -> SmallArray a -> SmallArray a Source #

createSmallArray :: Int -> a -> (forall s. SmallMutableArray s a -> ST s ()) -> SmallArray a Source #

arraySplitListN :: Size n -> [a] -> (Array n a, [a]) Source #

smallArraySplitListN :: Int -> [a] -> (SmallArray a, [a]) Source #

fromList :: Size n -> [a] -> Array n a Source #