-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Extras for the "primitive" library
--   
--   Extras for the "primitive" library
@package primitive-extras
@version 0.8

module PrimitiveExtras.SmallArray

-- | A workaround for the weird forcing of <a>undefined</a> values int
--   <a>newSmallArray</a>
newEmptySmallArray :: PrimMonad m => Int -> m (SmallMutableArray (PrimState m) a)
list :: [a] -> SmallArray a

-- | Remove an element.
unset :: Int -> SmallArray a -> SmallArray a
set :: Int -> a -> SmallArray a -> SmallArray a
insert :: Int -> a -> SmallArray a -> SmallArray a
cons :: a -> SmallArray a -> SmallArray a
orderedPair :: Int -> e -> Int -> e -> SmallArray e
find :: (a -> Bool) -> SmallArray a -> Maybe a
findWithIndex :: (a -> Bool) -> SmallArray a -> Maybe (Int, a)
elementsUnfoldlM :: Monad m => SmallArray e -> UnfoldlM m e
elementsListT :: Monad m => SmallArray a -> ListT m a
onFoundElementFocus :: Monad m => (a -> Bool) -> (a -> Bool) -> Focus a m b -> Focus (SmallArray a) m b
focusOnFoundElement :: Monad m => Focus a m b -> (a -> Bool) -> (a -> Bool) -> SmallArray a -> m (b, SmallArray a)
toList :: forall a. SmallArray a -> [a]

module PrimitiveExtras.Bitmap

-- | A word-size set of ints.
data Bitmap
empty :: Bitmap
singleton :: Int -> Bitmap
insert :: Int -> Bitmap -> Bitmap
invert :: Int -> Bitmap -> Bitmap
indexList :: [Int] -> Bitmap
boolList :: [Bool] -> Bitmap
pair :: Int -> Int -> Bitmap

-- | A number of non-zero bits, preceding this one.
populatedIndex :: Int -> Bitmap -> Int
isPopulated :: Int -> Bitmap -> Bool
population :: Bitmap -> Int
null :: Bitmap -> Bool
bits :: Bitmap -> [Int]
populatedIndicesList :: Bitmap -> [Int]
int :: Bitmap -> Int
allBitsList :: [Int]
allBitsUnfoldl :: Unfoldl Int
populatedBitsUnfoldl :: Bitmap -> Unfoldl Int
indicesAmongstPopulatedBitsUnfoldl :: Bitmap -> Unfoldl Int
instance GHC.Classes.Eq PrimitiveExtras.Types.Bitmap

module PrimitiveExtras.SparseSmallArray

-- | An immutable space-efficient sparse array, which can only store not
--   more than 32 or 64 elements depending on the system architecure.
data SparseSmallArray e
empty :: SparseSmallArray e

-- | An array with a single element at the specified index.
singleton :: Int -> e -> SparseSmallArray e
maybeList :: [Maybe e] -> SparseSmallArray e
pair :: Int -> e -> Int -> e -> SparseSmallArray e

-- | Insert an element value at the index. It's your obligation to ensure
--   that the index is empty before the operation.
insert :: Int -> e -> SparseSmallArray e -> SparseSmallArray e
replace :: Int -> e -> SparseSmallArray e -> SparseSmallArray e

-- | Remove an element.
unset :: Int -> SparseSmallArray e -> SparseSmallArray e

-- | Lookup an item at the index.
lookup :: Int -> SparseSmallArray e -> Maybe e
focusAt :: Monad m => Focus a m b -> Int -> SparseSmallArray a -> m (b, SparseSmallArray a)

-- | Convert into a list representation.
toMaybeList :: SparseSmallArray e -> [Maybe e]
toIndexedList :: SparseSmallArray e -> [(Int, e)]
elementsUnfoldl :: SparseSmallArray e -> Unfoldl e
elementsUnfoldlM :: Monad m => SparseSmallArray a -> UnfoldlM m a
elementsListT :: SparseSmallArray a -> ListT STM a
onElementAtFocus :: Monad m => Int -> Focus a m b -> Focus (SparseSmallArray a) m b
null :: SparseSmallArray a -> Bool
instance GHC.Classes.Eq a => GHC.Classes.Eq (PrimitiveExtras.Types.SparseSmallArray a)
instance GHC.Show.Show a => GHC.Show.Show (PrimitiveExtras.Types.SparseSmallArray a)
instance Data.Foldable.Foldable PrimitiveExtras.Types.SparseSmallArray

module PrimitiveExtras.UnliftedArray
at :: PrimUnlifted element => UnliftedArray element -> Int -> forall result. result -> (element -> result) -> result
replicateIO :: PrimUnlifted a => Int -> IO a -> IO (UnliftedArray a)
generate :: PrimUnlifted a => Int -> (Int -> IO a) -> IO (UnliftedArray a)
traverse_ :: (Monad m, PrimUnlifted a) => (a -> m ()) -> UnliftedArray a -> m ()

module PrimitiveExtras.PrimArray

-- | Construct from a primitive vector. In case the vector is not a slice,
--   it is an <i>O(1)</i> op.
primitiveVector :: Prim a => Vector a -> PrimArray a
oneHot :: Prim a => Int -> Int -> a -> PrimArray a
generate :: Prim a => Int -> (Int -> IO a) -> IO (PrimArray a)
replicate :: Prim a => Int -> IO a -> IO (PrimArray a)

-- | Please notice that this function is highly untested
replicateM :: (Monad m, Prim element) => Int -> m element -> m (PrimArray element)
traverse_ :: (Applicative f, Prim a) => (a -> f b) -> PrimArray a -> f ()
traverseWithIndexInRange_ :: Prim a => PrimArray a -> Int -> Int -> (Int -> a -> IO ()) -> IO ()
toElementsUnfoldl :: Prim prim => PrimArray prim -> Unfoldl prim
toElementsUnfoldlM :: (Monad m, Prim prim) => PrimArray prim -> UnfoldlM m prim
toByteArray :: PrimArray a -> ByteArray
toPrimitiveVector :: Prim a => PrimArray a -> Vector a
toUnboxedVector :: Prim a => PrimArray a -> Vector a
cerealGet :: Prim element => Get Int -> Get element -> Get (PrimArray element)
cerealGetAsInMemory :: Prim element => Get Int -> Get (PrimArray element)
cerealPut :: Prim element => Putter Int -> Putter element -> Putter (PrimArray element)
cerealPutAsInMemory :: Prim element => Putter Int -> Putter (PrimArray element)

-- | Given a size of the array, construct a fold, which produces an array
--   of index counts.
indexCountsFold :: (Integral count, Prim count) => Int -> Fold Int (PrimArray count)

-- | Given a size of the array, construct a fold, which produces an array
--   of elements.
elementsFoldM :: Prim a => Int -> FoldM IO a (PrimArray a)

module PrimitiveExtras.PrimMultiArray
data PrimMultiArray a

-- | Given a size of the outer array and a function, which executes a fold
--   over indexed elements in a monad, constructs a prim multi-array
create :: (Monad m, Prim element) => Int -> (forall x. Fold (Int, element) x -> m x) -> m (PrimMultiArray element)
replicateM :: (Monad m, Prim a) => Int -> m (PrimArray a) -> m (PrimMultiArray a)

-- | Get length of the outer dimension of a primitive multi array
outerLength :: PrimMultiArray a -> Int
toAssocsUnfoldl :: Prim a => PrimMultiArray a -> Unfoldl (Int, a)
toIndicesUnfoldl :: PrimMultiArray a -> Unfoldl Int
toUnfoldlAt :: Prim prim => PrimMultiArray prim -> Int -> Unfoldl prim
toAssocsUnfoldlM :: (Monad m, Prim a) => PrimMultiArray a -> UnfoldlM m (Int, a)
toIndicesUnfoldlM :: Monad m => PrimMultiArray a -> UnfoldlM m Int
toUnfoldlAtM :: (Monad m, Prim prim) => PrimMultiArray prim -> Int -> UnfoldlM m prim
cerealGet :: Prim element => Get Int -> Get element -> Get (PrimMultiArray element)
cerealGetAsInMemory :: Prim element => Get Int -> Get (PrimMultiArray element)
cerealPut :: Prim element => Putter Int -> Putter element -> Putter (PrimMultiArray element)
cerealPutAsInMemory :: Prim element => Putter Int -> Putter (PrimMultiArray element)

-- | Having a priorly computed array of inner dimension sizes, e.g., using
--   the <a>indexCountsFold</a>, construct a fold over indexed elements
--   into a multi-array of elements.
--   
--   Thus it allows to construct it in two passes over the indexed
--   elements.
fold :: (Integral size, Prim size, Prim element) => PrimArray size -> Fold (Int, element) (PrimMultiArray element)
instance (GHC.Classes.Eq a, Data.Primitive.Types.Prim a) => GHC.Classes.Eq (PrimitiveExtras.Types.PrimMultiArray a)
instance (GHC.Show.Show a, Data.Primitive.Types.Prim a) => GHC.Show.Show (PrimitiveExtras.Types.PrimMultiArray a)