primitive-0.6.2.0: Primitive memory-related operations

Copyright | (c) 2015 Dan Doel
License | BSD3
Maintainer | libraries@haskell.org
Portability | non-portable
Safe Haskell | None
Language | Haskell2010

Data.Primitive.SmallArray

Description

Small arrays are boxed (im)mutable arrays.

The underlying structure of the `Array` type contains a card table, allowing segments of the array to be marked as having been mutated. This allows the garbage collector to only re-traverse segments of the array that have been marked during certain phases, rather than having to traverse the entire array.

`SmallArray` lacks this table. This means that it takes up less memory and has slightly faster writes. It is also more efficient during garbage collection so long as the card table would have a single entry covering the entire array. These advantages make them suitable for use as arrays that are known to be small.

The card size is 128, so for uses much larger than that, `Array` would likely be superior.

The underlying type, `SmallArray#`, was introduced in GHC 7.10, so prior to that version, this module simply implements small arrays as `Array`.

Synopsis

- data SmallArray a = SmallArray (SmallArray# a)
- data SmallMutableArray s a = SmallMutableArray (SmallMutableArray# s a)
- newSmallArray :: PrimMonad m => Int -> a -> m (SmallMutableArray (PrimState m) a)
- readSmallArray :: PrimMonad m => SmallMutableArray (PrimState m) a -> Int -> m a
- writeSmallArray :: PrimMonad m => SmallMutableArray (PrimState m) a -> Int -> a -> m ()
- copySmallArray :: PrimMonad m => SmallMutableArray (PrimState m) a -> Int -> SmallArray a -> Int -> Int -> m ()
- copySmallMutableArray :: PrimMonad m => SmallMutableArray (PrimState m) a -> Int -> SmallMutableArray (PrimState m) a -> Int -> Int -> m ()
- indexSmallArray :: SmallArray a -> Int -> a
- indexSmallArrayM :: Monad m => SmallArray a -> Int -> m a
- cloneSmallArray :: SmallArray a -> Int -> Int -> SmallArray a
- cloneSmallMutableArray :: PrimMonad m => SmallMutableArray (PrimState m) a -> Int -> Int -> m (SmallMutableArray (PrimState m) a)
- freezeSmallArray :: PrimMonad m => SmallMutableArray (PrimState m) a -> Int -> Int -> m (SmallArray a)
- unsafeFreezeSmallArray :: PrimMonad m => SmallMutableArray (PrimState m) a -> m (SmallArray a)
- thawSmallArray :: PrimMonad m => SmallArray a -> Int -> Int -> m (SmallMutableArray (PrimState m) a)
- unsafeThawSmallArray :: PrimMonad m => SmallArray a -> m (SmallMutableArray (PrimState m) a)
- sizeofSmallArray :: SmallArray a -> Int
- sizeofSmallMutableArray :: SmallMutableArray s a -> Int

# Documentation

data SmallArray a #

Constructors

SmallArray (SmallArray# a) |

Instances

Monad SmallArray # |
Methods (>>=) :: SmallArray a -> (a -> SmallArray b) -> SmallArray b # (>>) :: SmallArray a -> SmallArray b -> SmallArray b # return :: a -> SmallArray a # fail :: String -> SmallArray a #
Functor SmallArray # |
Methods fmap :: (a -> b) -> SmallArray a -> SmallArray b # (<$) :: a -> SmallArray b -> SmallArray a #
MonadFix SmallArray # |
Methods mfix :: (a -> SmallArray a) -> SmallArray a #
Applicative SmallArray # |
Methods pure :: a -> SmallArray a # (<*>) :: SmallArray (a -> b) -> SmallArray a -> SmallArray b # (*>) :: SmallArray a -> SmallArray b -> SmallArray b # (<*) :: SmallArray a -> SmallArray b -> SmallArray a #
Foldable SmallArray # |
Methods fold :: Monoid m => SmallArray m -> m # foldMap :: Monoid m => (a -> m) -> SmallArray a -> m # foldr :: (a -> b -> b) -> b -> SmallArray a -> b # foldr' :: (a -> b -> b) -> b -> SmallArray a -> b # foldl :: (b -> a -> b) -> b -> SmallArray a -> b # foldl' :: (b -> a -> b) -> b -> SmallArray a -> b # foldr1 :: (a -> a -> a) -> SmallArray a -> a # foldl1 :: (a -> a -> a) -> SmallArray a -> a # toList :: SmallArray a -> [a] # null :: SmallArray a -> Bool # length :: SmallArray a -> Int # elem :: Eq a => a -> SmallArray a -> Bool # maximum :: Ord a => SmallArray a -> a # minimum :: Ord a => SmallArray a -> a # sum :: Num a => SmallArray a -> a # product :: Num a => SmallArray a -> a #
Traversable SmallArray # |
Methods traverse :: Applicative f => (a -> f b) -> SmallArray a -> f (SmallArray b) # sequenceA :: Applicative f => SmallArray (f a) -> f (SmallArray a) # mapM :: Monad m => (a -> m b) -> SmallArray a -> m (SmallArray b) # sequence :: Monad m => SmallArray (m a) -> m (SmallArray a) #
MonadZip SmallArray # |
Methods mzip :: SmallArray a -> SmallArray b -> SmallArray (a, b) # mzipWith :: (a -> b -> c) -> SmallArray a -> SmallArray b -> SmallArray c # munzip :: SmallArray (a, b) -> (SmallArray a, SmallArray b) #
Alternative SmallArray # |
Methods empty :: SmallArray a # (<|>) :: SmallArray a -> SmallArray a -> SmallArray a # some :: SmallArray a -> SmallArray [a] # many :: SmallArray a -> SmallArray [a] #
MonadPlus SmallArray # |
Methods mzero :: SmallArray a # mplus :: SmallArray a -> SmallArray a -> SmallArray a #
IsList (SmallArray a) # |
Associated Types type Item (SmallArray a) :: * # Methods fromList :: [Item (SmallArray a)] -> SmallArray a # fromListN :: Int -> [Item (SmallArray a)] -> SmallArray a # toList :: SmallArray a -> [Item (SmallArray a)] #
Eq a => Eq (SmallArray a) # |
Methods (==) :: SmallArray a -> SmallArray a -> Bool # (/=) :: SmallArray a -> SmallArray a -> Bool #
Data a => Data (SmallArray a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SmallArray a -> c (SmallArray a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SmallArray a) # toConstr :: SmallArray a -> Constr # dataTypeOf :: SmallArray a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (SmallArray a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SmallArray a)) # gmapT :: (forall b. Data b => b -> b) -> SmallArray a -> SmallArray a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SmallArray a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SmallArray a -> r # gmapQ :: (forall d. Data d => d -> u) -> SmallArray a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SmallArray a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SmallArray a -> m (SmallArray a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SmallArray a -> m (SmallArray a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SmallArray a -> m (SmallArray a) #
Ord a => Ord (SmallArray a) # |
Methods compare :: SmallArray a -> SmallArray a -> Ordering # (<) :: SmallArray a -> SmallArray a -> Bool # (<=) :: SmallArray a -> SmallArray a -> Bool # (>) :: SmallArray a -> SmallArray a -> Bool # (>=) :: SmallArray a -> SmallArray a -> Bool # max :: SmallArray a -> SmallArray a -> SmallArray a # min :: SmallArray a -> SmallArray a -> SmallArray a #
Read a => Read (SmallArray a) # |
Methods readsPrec :: Int -> ReadS (SmallArray a) # readList :: ReadS [SmallArray a] # readPrec :: ReadPrec (SmallArray a) # readListPrec :: ReadPrec [SmallArray a] #
Show a => Show (SmallArray a) # |
Methods showsPrec :: Int -> SmallArray a -> ShowS # show :: SmallArray a -> String # showList :: [SmallArray a] -> ShowS #
Monoid (SmallArray a) # |
Methods mempty :: SmallArray a # mappend :: SmallArray a -> SmallArray a -> SmallArray a # mconcat :: [SmallArray a] -> SmallArray a #
PrimUnlifted (SmallArray a) # |
Methods toArrayArray# :: SmallArray a -> ArrayArray# # fromArrayArray# :: ArrayArray# -> SmallArray a #
type Item (SmallArray a) # |
type Item (SmallArray a) = a

data SmallMutableArray s a #

Constructors

SmallMutableArray (SmallMutableArray# s a) |

Instances

Eq (SmallMutableArray s a) # |
Methods (==) :: SmallMutableArray s a -> SmallMutableArray s a -> Bool # (/=) :: SmallMutableArray s a -> SmallMutableArray s a -> Bool #
(Typeable * s, Typeable * a) => Data (SmallMutableArray s a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SmallMutableArray s a -> c (SmallMutableArray s a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SmallMutableArray s a) # toConstr :: SmallMutableArray s a -> Constr # dataTypeOf :: SmallMutableArray s a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (SmallMutableArray s a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SmallMutableArray s a)) # gmapT :: (forall b. Data b => b -> b) -> SmallMutableArray s a -> SmallMutableArray s a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SmallMutableArray s a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SmallMutableArray s a -> r # gmapQ :: (forall d. Data d => d -> u) -> SmallMutableArray s a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SmallMutableArray s a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SmallMutableArray s a -> m (SmallMutableArray s a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SmallMutableArray s a -> m (SmallMutableArray s a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SmallMutableArray s a -> m (SmallMutableArray s a) #
PrimUnlifted (SmallMutableArray s a) # |
Methods toArrayArray# :: SmallMutableArray s a -> ArrayArray# # fromArrayArray# :: ArrayArray# -> SmallMutableArray s a #

newSmallArray #

Arguments

:: PrimMonad m |
=> Int | size
-> a | initial contents
-> m (SmallMutableArray (PrimState m) a) |

Create a new small mutable array.

readSmallArray #

Arguments

:: PrimMonad m |
=> SmallMutableArray (PrimState m) a | array
-> Int | index
-> m a |

Read the element at a given index in a mutable array.

writeSmallArray #

Arguments

:: PrimMonad m |
=> SmallMutableArray (PrimState m) a | array
-> Int | index
-> a | new element
-> m () |

Write an element at the given idex in a mutable array.

copySmallArray #

Arguments

:: PrimMonad m |
=> SmallMutableArray (PrimState m) a | destination
-> Int | destination offset
-> SmallArray a | source
-> Int | source offset
-> Int | length
-> m () |

Copy a slice of an immutable array into a mutable array.

copySmallMutableArray #

Arguments

:: PrimMonad m |
=> SmallMutableArray (PrimState m) a | destination
-> Int | destination offset
-> SmallMutableArray (PrimState m) a | source
-> Int | source offset
-> Int | length
-> m () |

Copy a slice of one mutable array into another.

indexSmallArray #

Arguments

:: SmallArray a | array
-> Int | index
-> a |

Look up an element in an immutable array.

indexSmallArrayM #

Arguments

:: Monad m |
=> SmallArray a | array
-> Int | index
-> m a |

Look up an element in an immutable array.

The purpose of returning a result using a monad is to allow the caller to avoid retaining references to the array. Evaluating the return value will cause the array lookup to be performed, even though it may not require the element of the array to be evaluated (which could throw an exception). For instance:

    data Box a = Box a
    ...

    f sa = case indexSmallArrayM sa 0 of
      Box x -> ...

`x` is not a closure that references `sa` as it would be if we instead wrote:

    let x = indexSmallArray sa 0

And does not prevent `sa` from being garbage collected.

Note that `Identity` is not adequate for this use, as it is a newtype, and cannot be evaluated without evaluating the element.

cloneSmallArray #

Arguments

:: SmallArray a | source
-> Int | offset
-> Int | length
-> SmallArray a |

Create a copy of a slice of an immutable array.

cloneSmallMutableArray #

Arguments

:: PrimMonad m |
=> SmallMutableArray (PrimState m) a | source
-> Int | offset
-> Int | length
-> m (SmallMutableArray (PrimState m) a) |

Create a copy of a slice of a mutable array.

freezeSmallArray #

Arguments

:: PrimMonad m |
=> SmallMutableArray (PrimState m) a | source
-> Int | offset
-> Int | length
-> m (SmallArray a) |

Create an immutable array corresponding to a slice of a mutable array.

This operation copies the portion of the array to be frozen.

unsafeFreezeSmallArray :: PrimMonad m => SmallMutableArray (PrimState m) a -> m (SmallArray a) #

Render a mutable array immutable.

This operation performs no copying, so care must be taken not to modify the input array after freezing.

thawSmallArray #

Arguments

:: PrimMonad m |
=> SmallArray a | source
-> Int | offset
-> Int | length
-> m (SmallMutableArray (PrimState m) a) |

Create a mutable array corresponding to a slice of an immutable array.

This operation copies the portion of the array to be thawed.

unsafeThawSmallArray :: PrimMonad m => SmallArray a -> m (SmallMutableArray (PrimState m) a) #

Render an immutable array mutable.

This operation performs no copying, so care must be taken with its use.

sizeofSmallArray :: SmallArray a -> Int #

sizeofSmallMutableArray :: SmallMutableArray s a -> Int #