ListLike-4.5: Generic support for list-like structures

CopyrightCopyright (C) 2007 John Goerzen
LicenseBSD3
MaintainerJohn Lato <jwlato@gmail.com>
Stabilityprovisional
Portabilityportable
Safe HaskellSafe
LanguageHaskell98

Data.ListLike.FoldableLL

Contents

Description

Generic tools for data structures that can be folded.

Written by John Goerzen, jgoerzen@complete.org

Synopsis

FoldableLL Class

class FoldableLL full item | full -> item where #

This is the primary class for structures that are to be considered foldable. A minimum complete definition provides foldl and foldr.

Instances of FoldableLL can be folded, and can be many and varied.

These functions are used heavily in Data.ListLike.

Minimal complete definition

foldl, foldr

Methods

foldl :: (a -> item -> a) -> a -> full -> a #

Left-associative fold

foldl' :: (a -> item -> a) -> a -> full -> a #

Strict version of foldl.

foldl1 :: (item -> item -> item) -> full -> item #

A variant of foldl with no base case. Requires at least 1 list element.

foldr :: (item -> b -> b) -> b -> full -> b #

Right-associative fold

foldr' :: (item -> b -> b) -> b -> full -> b #

Strict version of foldr

foldr1 :: (item -> item -> item) -> full -> item #

Like foldr, but with no starting value

Instances

FoldableLL CharStringLazy Char # 

Methods

foldl :: (a -> Char -> a) -> a -> CharStringLazy -> a #

foldl' :: (a -> Char -> a) -> a -> CharStringLazy -> a #

foldl1 :: (Char -> Char -> Char) -> CharStringLazy -> Char #

foldr :: (Char -> b -> b) -> b -> CharStringLazy -> b #

foldr' :: (Char -> b -> b) -> b -> CharStringLazy -> b #

foldr1 :: (Char -> Char -> Char) -> CharStringLazy -> Char #

FoldableLL CharString Char # 

Methods

foldl :: (a -> Char -> a) -> a -> CharString -> a #

foldl' :: (a -> Char -> a) -> a -> CharString -> a #

foldl1 :: (Char -> Char -> Char) -> CharString -> Char #

foldr :: (Char -> b -> b) -> b -> CharString -> b #

foldr' :: (Char -> b -> b) -> b -> CharString -> b #

foldr1 :: (Char -> Char -> Char) -> CharString -> Char #

FoldableLL Chars Char # 

Methods

foldl :: (a -> Char -> a) -> a -> Chars -> a #

foldl' :: (a -> Char -> a) -> a -> Chars -> a #

foldl1 :: (Char -> Char -> Char) -> Chars -> Char #

foldr :: (Char -> b -> b) -> b -> Chars -> b #

foldr' :: (Char -> b -> b) -> b -> Chars -> b #

foldr1 :: (Char -> Char -> Char) -> Chars -> Char #

FoldableLL [a] a # 

Methods

foldl :: (a -> a -> a) -> a -> [a] -> a #

foldl' :: (a -> a -> a) -> a -> [a] -> a #

foldl1 :: (a -> a -> a) -> [a] -> a #

foldr :: (a -> b -> b) -> b -> [a] -> b #

foldr' :: (a -> b -> b) -> b -> [a] -> b #

foldr1 :: (a -> a -> a) -> [a] -> a #

Utilities

fold :: (FoldableLL full item, Monoid item) => full -> item #

Combine the elements of a structure using a monoid. fold = foldMap id

foldMap :: (FoldableLL full item, Monoid m) => (item -> m) -> full -> m #

Map each element to a monoid, then combine the results

foldM :: (Monad m, FoldableLL full item) => (a -> item -> m a) -> a -> full -> m a #

Monadic version of left fold, similar to foldM.

sequence_ :: (Monad m, FoldableLL full (m item)) => full -> m () #

Evaluate each action, ignoring the results. Same as mapM_ id.

mapM_ :: (Monad m, FoldableLL full item) => (item -> m b) -> full -> m () #

A map in monad space, discarding results.