pinch- An alternative implementation of Thrift for Haskell.

Copyright(c) Abhinav Gupta 2015
MaintainerAbhinav Gupta <>
Safe HaskellSafe



Implements a representation of a list as a fold over it.



data FoldList a Source

FoldList represents a list as a foldl' traversal over it.

This allows us to avoid allocating new collections for an intermediate representation of various data types that users provide.

map :: (a -> b) -> FoldList a -> FoldList b Source

Applies the given function to all elements in the FoldList.

Note that the function is applied lazily when the results are requested. If the results of the same FoldList are requested multiple times, the function will be called multiple times on the same elements.

replicate :: Int -> a -> FoldList a Source

Returns a FoldList with the given item repeated n times.

replicateM :: Monad m => Int -> m a -> m (FoldList a) Source

Executes the given monadic action the given number of times and returns a FoldList of the results.

foldl' :: Foldable t => forall b a. (b -> a -> b) -> b -> t a -> b

Left-associative fold of a structure. but with strict application of the operator.

foldl f z = foldl' f z . toList

foldr :: Foldable t => forall a b. (a -> b -> b) -> b -> t a -> b

Right-associative fold of a structure.

foldr f z = foldr f z . toList

toList :: Foldable t => forall a. t a -> [a]

List of elements of a structure, from left to right.

fromFoldable :: Foldable f => f a -> FoldList a Source

Builds a FoldList from a Foldable.

fromMap Source


:: (forall r. (r -> k -> v -> r) -> r -> m k v -> r)

foldlWithKey provided by the map implementation.

-> m k v 
-> FoldList (k, v) 

Builds a FoldList over pairs of items of a map.

mapM :: Traversable t => forall a m b. Monad m => (a -> m b) -> t a -> m (t b)

Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see mapM_.

sequence :: Traversable t => forall m a. Monad m => t (m a) -> m (t a)

Evaluate each monadic action in the structure from left to right, and collect the results. For a version that ignores the results see sequence_.