Hoogle Search

Within LTS Haskell 24.34 (ghc-9.10.3)

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

Exact lookup

1. gmapQl :: Data a => (r -> r' -> r) -> r -> (forall d . Data d => d -> r') -> a -> r

   base	Data.Data

   A generic query with a left-associative binary operator

2. gmapQr :: forall r r' . Data a => (r' -> r -> r) -> r -> (forall d . Data d => d -> r') -> a -> r

   base	Data.Data

   A generic query with a right-associative binary operator

3. gmapT :: Data a => (forall b . Data b => b -> b) -> a -> a

   base	Data.Data

   A generic transformation that maps over the immediate subterms The default definition instantiates the type constructor c in the type of gfoldl to an identity datatype constructor, using the isomorphism pair as injection and projection.

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

   base	Data.Foldable

   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]
   

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

   base	Data.Foldable

   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"
   

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

   base	Data.Foldable

   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"
   

7. foldMap1 :: (Foldable1 t, Semigroup m) => (a -> m) -> t a -> m

   base	Data.Foldable1

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

   >>> foldMap1 (:[]) (1 :| [2, 3, 4])
   [1,2,3,4]
   

8. foldMap1' :: (Foldable1 t, Semigroup m) => (a -> m) -> t a -> m

   base	Data.Foldable1

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

   >>> foldMap1' Sum (1 :| [2, 3, 4])
   Sum {getSum = 10}
   

9. foldlMap1 :: Foldable1 t => (a -> b) -> (b -> a -> b) -> t a -> b

   base	Data.Foldable1

   Left-associative fold of a structure, lazy in the accumulator. This is rarely what you want, but can work well for structures with efficient right-to-left sequencing and an operator that is lazy in its left argument. In case of NonEmpty lists, foldlMap1, when given a function f, a binary operator g, and a list, reduces the list using g from left to right applying f to the leftmost element:

   foldlMap1 f g (x1 :| [x2, ..., xn]) == (...(((f x1) `g` x2) `g`...) `g` xn
   

   Note that to produce the outermost application of the operator the entire input list must be traversed. This means that foldlMap1 will diverge if given an infinite list. If you want an efficient strict left-fold, you probably want to use foldlMap1' instead of foldlMap1. The reason for this is that the latter does not force the inner results (e.g. (f x1) `g` x2 in the above example) before applying them to the operator (e.g. to (`g` x3)). This results in a thunk chain <math> elements long, which then must be evaluated from the outside-in. For a general Foldable1 structure this should be semantically identical to:

   foldlMap1 f g = foldlMap1 f g . toNonEmpty
   

10. foldlMap1' :: Foldable1 t => (a -> b) -> (b -> a -> b) -> t a -> b

    base	Data.Foldable1

    Left-associative fold of a structure but with strict application of the operator. This ensures that each step of the fold is forced to Weak Head Normal Form before being applied, avoiding the collection of thunks that would otherwise occur. This is often what you want to strictly reduce a finite structure to a single strict result. For a general Foldable1 structure this should be semantically identical to:

    foldlMap1' f z = foldlMap1' f z . toNonEmpty
    

Page 399 of many | Previous | Next