Hoogle Search

Within LTS Haskell 24.40 (ghc-9.10.3)

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

  1. fmapToSnd :: Functor f => (a -> b) -> f a -> f (a, b)

    relude Relude.Extra.Tuple

    Like fmap, but also keep the original value in the fst position. A dual to fmapToFst. 

    >>> fmapToSnd show [3, 10, 2]
[(3,"3"),(10,"10"),(2,"2")]

  2. asumMap :: forall b m f a . (Foldable f, Alternative m) => (a -> m b) -> f a -> m b

    relude Relude.Foldable.Fold

    Alternative version of asum that takes a function to map over. 

    >>> asumMap (\x -> if x > 2 then Just x else Nothing) [1..4]
Just 3

  3. foldMapA :: (Semigroup b, Monoid b, Applicative m, Foldable f) => (a -> m b) -> f a -> m b

    relude Relude.Foldable.Fold

    Polymorphic version of the concatMapA function. 

    >>> foldMapA @[Int] (Just . replicate 3) [1..3]
Just [1,1,1,2,2,2,3,3,3]

  4. foldMapM :: (Monoid b, Monad m, Foldable f) => (a -> m b) -> f a -> m b

    relude Relude.Foldable.Fold

    Polymorphic version of the concatMapM function. 

    >>> foldMapM @[Int] (Just . replicate 3) [1..3]
Just [1,1,1,2,2,2,3,3,3]

  5. bifoldMap :: (Bifoldable p, Monoid m) => (a -> m) -> (b -> m) -> p a b -> m

    relude Relude.Foldable.Reexport

    Combines the elements of a structure, given ways of mapping them to a common monoid. 

    bifoldMap f g ≡ bifoldr (mappend . f) (mappend . g) mempty

    Examples

    Basic usage: 
    >>> bifoldMap (take 3) (fmap digitToInt) ([1..], "89")
[1,2,3,8,9]

    >>> bifoldMap (take 3) (fmap digitToInt) (Left [1..])
[1,2,3]

    >>> bifoldMap (take 3) (fmap digitToInt) (Right "89")
[8,9]

  6. bifoldMapDefault :: (Bitraversable t, Monoid m) => (a -> m) -> (b -> m) -> t a b -> m

    relude Relude.Foldable.Reexport

    A default definition of bifoldMap in terms of the Bitraversable operations. 

    bifoldMapDefault f g ≡
getConst . bitraverse (Const . f) (Const . g)

  7. bimapDefault :: Bitraversable t => (a -> b) -> (c -> d) -> t a c -> t b d

    relude Relude.Foldable.Reexport

    A default definition of bimap in terms of the Bitraversable operations. 

    bimapDefault f g ≡
runIdentity . bitraverse (Identity . f) (Identity . g)

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

    relude Relude.Foldable.Reexport

    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

    relude Relude.Foldable.Reexport

    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

    relude Relude.Foldable.Reexport

    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 515 of many | Previous | Next