Hoogle Search

Within LTS Haskell 24.45 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

  1. foldMap' :: (Monoid m, Unbox a) => (a -> m) -> Vector a -> m

    rebase Rebase.Data.Vector.Unboxed

    No documentation available.

  2. imap :: (Unbox a, Unbox b) => (Int -> a -> b) -> Vector a -> Vector b

    rebase Rebase.Data.Vector.Unboxed

    No documentation available.

  3. imapM :: (Monad m, Unbox a, Unbox b) => (Int -> a -> m b) -> Vector a -> m (Vector b)

    rebase Rebase.Data.Vector.Unboxed

    No documentation available.

  4. imapM_ :: (Monad m, Unbox a) => (Int -> a -> m b) -> Vector a -> m ()

    rebase Rebase.Data.Vector.Unboxed

    No documentation available.

  5. imapMaybe :: (Unbox a, Unbox b) => (Int -> a -> Maybe b) -> Vector a -> Vector b

    rebase Rebase.Data.Vector.Unboxed

    No documentation available.

  6. imapMaybeM :: (Monad m, Unbox a, Unbox b) => (Int -> a -> m (Maybe b)) -> Vector a -> m (Vector b)

    rebase Rebase.Data.Vector.Unboxed

    No documentation available.

  7. imapM_ :: (PrimMonad m, Unbox a) => (Int -> a -> m b) -> MVector (PrimState m) a -> m ()

    rebase Rebase.Data.Vector.Unboxed.Mutable

    No documentation available.

  8. data HashMap k v

    rebase Rebase.Prelude

    A map from keys to values. A map cannot contain duplicate keys; each key can map to at most one value.

  9. data IntMap a

    rebase Rebase.Prelude

    A map of integers to values a.

  10. foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m

    rebase Rebase.Prelude

    Map each element of the structure into a monoid, and combine the results with (<>). This fold is right-associative and lazy in the accumulator. For strict left-associative folds consider foldMap' instead.

    Examples

    Basic usage: 
    >>> foldMap Sum [1, 3, 5]
Sum {getSum = 9}

    >>> foldMap Product [1, 3, 5]
Product {getProduct = 15}

    >>> foldMap (replicate 3) [1, 2, 3]
[1,1,1,2,2,2,3,3,3]
    When a Monoid's (<>) is lazy in its second argument, foldMap can return a result even from an unbounded structure. For example, lazy accumulation enables Data.ByteString.Builder to efficiently serialise large data structures and produce the output incrementally: 
    >>> import qualified Data.ByteString.Lazy as L

>>> import qualified Data.ByteString.Builder as B

>>> let bld :: Int -> B.Builder; bld i = B.intDec i <> B.word8 0x20

>>> let lbs = B.toLazyByteString $ foldMap bld [0..]

>>> L.take 64 lbs
"0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24"

Page 972 of many | Previous | Next