Hoogle Search

Within LTS Haskell 24.36 (ghc-9.10.3)

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

Exact lookup

1. gmapQ :: Data a => (forall d . Data d => d -> u) -> a -> [u]

   base	Data.Data

   A generic query that processes the immediate subterms and returns a list of results. The list is given in the same order as originally specified in the declaration of the data constructors.

2. gmapQi :: Data a => Int -> (forall d . Data d => d -> u) -> a -> u

   base	Data.Data

   A generic query that processes one child by index (zero-based)

3. 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

4. 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

5. 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.

6. 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]
   

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

8. 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"
   

9. 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]
   

10. 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}
    

Page 399 of many | Previous | Next