ListLike-4.5.1: Generic support for list-like structures

Copyright | Copyright (C) 2007 John Goerzen
License | BSD3
Maintainer | John Lato <jwlato@gmail.com>
Stability | provisional
Portability | portable
Safe Haskell | Safe
Language | Haskell98

Data.ListLike.FoldableLL

Contents

- FoldableLL Class
- Utilities

Description

Generic tools for data structures that can be folded.

Written by John Goerzen, jgoerzen@complete.org

Synopsis

- class FoldableLL full item | full -> item where
- fold :: (FoldableLL full item, Monoid item) => full -> item
- foldMap :: (FoldableLL full item, Monoid m) => (item -> m) -> full -> m
- foldM :: (Monad m, FoldableLL full item) => (a -> item -> m a) -> a -> full -> m a
- sequence_ :: (Monad m, FoldableLL full (m item)) => full -> m ()
- mapM_ :: (Monad m, FoldableLL full item) => (item -> m b) -> full -> m ()

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