Hoogle Search

Within LTS Haskell 24.52 (ghc-9.10.3)

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

  1. class HasMapping s a | s -> a

    openapi3 Data.OpenApi.Lens

    No documentation available.

  2. data OMap k v

    ordered-containers Data.Map.Ordered

    No documentation available.

  3. toMap :: OMap k v -> Map k v

    ordered-containers Data.Map.Ordered

    Convert an OMap to a Map. O(n), where n is the size of the OMap.

  4. data OMap k v

    ordered-containers Data.Map.Ordered.Strict

    No documentation available.

  5. toMap :: OMap k v -> Map k v

    ordered-containers Data.Map.Ordered.Strict

    Convert an OMap to a Map. O(n), where n is the size of the OMap.

  6. concatMap :: forall (m :: Type -> Type) r . Monad m => (Word8 -> ByteString) -> Pipe ByteString ByteString m r

    pipes-bytestring Pipes.ByteString

    Map a function over the byte stream and concatenate the results

  7. foldMapBuilder :: Vector v a => (a -> Builder) -> v a -> Builder

    proto-lens Data.ProtoLens.Encoding.Bytes

    Loop over the elements of a vector and concatenate the resulting Builders. This function has been hand-tuned to perform better than a naive implementation using, e.g., Vector.foldr or a manual loop.

  8. data IntMap a

    protolude Protolude

    A map of integers to values a.

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

    protolude Protolude

    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]

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

    protolude Protolude

    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"

Page 574 of many | Previous | Next