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. DMap :: HashMap Text DefaultValue -> DefaultValue

    avro Data.Avro.Schema.Schema

    Dynamically enforced monomorphic type

  2. btmap1 :: (FunctorB (b f), FunctorT b) => (forall (a :: k) . () => f a -> g a) -> b f f -> b g g

    barbies Barbies.Bi

    A version of btmap specialized to a single argument.

  3. gbmapDefault :: CanDeriveFunctorB b f g => (forall (a :: k) . () => f a -> g a) -> b f -> b g

    barbies Barbies.Internal

    Default implementation of bmap based on Generic.

  4. gmap :: forall (x :: k1) . GFunctor n f g repbf repbg => Proxy n -> (forall (a :: k) . () => f a -> g a) -> repbf x -> repbg x

    barbies Barbies.Internal

    No documentation available.

  5. bfoldMap :: (TraversableB b, Monoid m) => (forall (a :: k) . () => f a -> m) -> b f -> m

    barbies Data.Functor.Barbie

    Map each element to a monoid, and combine the results.

  6. bmap :: FunctorB b => (forall (a :: k) . () => f a -> g a) -> b f -> b g

    barbies Data.Functor.Barbie

    No documentation available.

  7. bmapC :: (AllB c b, ConstraintsB b) => (forall (a :: k) . c a => f a -> g a) -> b f -> b g

    barbies Data.Functor.Barbie

    Like bmap but a constraint is allowed to be required on each element of b E.g. If all fields of b are Showable then you could store each shown value in it's slot using Const: 

    showFields :: (AllB Show b, ConstraintsB b) => b Identity -> b (Const String)
showFields = bmapC @Show showField
where
showField :: forall a. Show a => Identity a -> Const String a
showField (Identity a) = Const (show a)
    Notice that one can use the (&) class as a way to require several constraiints to hold simultaneously: 
    bmap @(Show & Eq & Enum) r

  8. tmap :: forall f g (x :: k') . FunctorT t => (forall (a :: k) . () => f a -> g a) -> t f x -> t g x

    barbies Data.Functor.Transformer

    No documentation available.

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

    base-prelude BasePrelude

    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

    base-prelude BasePrelude

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