Hoogle Search

Within LTS Haskell 24.6 (ghc-9.10.2)

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

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

    cabal-install-solver Distribution.Solver.Compat.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"

  2. gmappend :: (Generic a, GSemigroup (Rep a)) => a -> a -> a

    cabal-install-solver Distribution.Solver.Compat.Prelude

    Generically generate a Semigroup (<>) operation for any type implementing Generic. This operation will append two values by point-wise appending their component fields. It is only defined for product types. 

    gmappend a (gmappend b c) = gmappend (gmappend a b) c

  3. type DebMap = Map BinPkgName Maybe DebianVersion

    cabal-debian Debian.Debianize.Prelude

    No documentation available.

  4. buildDebVersionMap :: IO DebMap

    cabal-debian Debian.Debianize.Prelude

    Query versions of installed packages

  5. dpkgFileMap :: IO (Map FilePath (Set BinPkgName))

    cabal-debian Debian.Debianize.Prelude

    Create a map from pathname to the names of the packages that contains that pathname using the contents of the debian package info directory varlibdpkginfo.

  6. setMapMaybe :: Ord b => (a -> Maybe b) -> Set a -> Set b

    cabal-debian Debian.Debianize.Prelude

    No documentation available.

  7. zipMaps :: Ord k => (k -> Maybe a -> Maybe b -> Maybe c) -> Map k a -> Map k b -> Map k c

    cabal-debian Debian.Debianize.Prelude

    No documentation available.

  8. concatMap :: Foldable t => (a -> [b]) -> t a -> [b]

    calligraphy Calligraphy.Prelude

    Map a function over all the elements of a container and concatenate the resulting lists.

    Examples

    Basic usage: 
    >>> concatMap (take 3) [[1..], [10..], [100..], [1000..]]
[1,2,3,10,11,12,100,101,102,1000,1001,1002]

    >>> concatMap (take 3) (Just [1..])
[1,2,3]

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

    calligraphy Calligraphy.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"

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

    calligraphy Calligraphy.Prelude

    A left-associative variant of foldMap that is strict in the accumulator. Use this method for strict reduction when partial results are merged via (<>).

    Examples

    Define a Monoid over finite bit strings under xor. Use it to strictly compute the xor of a list of Int values. 
    >>> :set -XGeneralizedNewtypeDeriving

>>> import Data.Bits (Bits, FiniteBits, xor, zeroBits)

>>> import Data.Foldable (foldMap')

>>> import Numeric (showHex)

>>> 

>>> newtype X a = X a deriving (Eq, Bounded, Enum, Bits, FiniteBits)

>>> instance Bits a => Semigroup (X a) where X a <> X b = X (a `xor` b)

>>> instance Bits a => Monoid    (X a) where mempty     = X zeroBits

>>> 

>>> let bits :: [Int]; bits = [0xcafe, 0xfeed, 0xdeaf, 0xbeef, 0x5411]

>>> (\ (X a) -> showString "0x" . showHex a $ "") $ foldMap' X bits
"0x42"

Page 29 of many | Previous | Next