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. bmap :: FunctorB b => (forall (a :: k) . () => f a -> g a) -> b f -> b g

    barbies Data.Functor.Barbie

    No documentation available.

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

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

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

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

  6. bmap :: Monad m => (a' -> m (Maybe a)) -> (b -> m (Maybe b')) -> Box m a b -> Box m a' b'

    box Box.Box

    A profunctor dimapMaybe

  7. newtype ReferenceMap a

    citeproc Citeproc.Types

    No documentation available.

  8. ReferenceMap :: Map ItemId (Reference a) -> ReferenceMap a

    citeproc Citeproc.Types

    No documentation available.

  9. disambNameMap :: DisambiguationData -> Map Name NameHints

    citeproc Citeproc.Types

    No documentation available.

  10. makeReferenceMap :: [Reference a] -> ([Reference a], ReferenceMap a)

    citeproc Citeproc.Types

    Returns a pair consisting of the cleaned up list of references and a reference map. If the original reference list contains items with the same id, then the one that occurs last in the list is retained, and the others are omittedfrom the cleaned-up list.

Page 978 of many | Previous | Next