Portability | portable |
---|---|

Stability | stable |

Maintainer | sean.leather@gmail.com |

Safe Haskell | Safe-Inferred |

Difference lists: a data structure for *O(1)* append on lists.

- data DList a
- fromList :: [a] -> DList a
- toList :: DList a -> [a]
- apply :: DList a -> [a] -> [a]
- empty :: DList a
- singleton :: a -> DList a
- cons :: a -> DList a -> DList a
- snoc :: DList a -> a -> DList a
- append :: DList a -> DList a -> DList a
- concat :: [DList a] -> DList a
- replicate :: Int -> a -> DList a
- list :: b -> (a -> DList a -> b) -> DList a -> b
- head :: DList a -> a
- tail :: DList a -> DList a
- unfoldr :: (b -> Maybe (a, b)) -> b -> DList a
- foldr :: (a -> b -> b) -> b -> DList a -> b
- map :: (a -> b) -> DList a -> DList b

# Documentation

A difference list is a function that, given a list, returns the original contents of the difference list prepended to the given list.

This structure supports *O(1)* append and snoc operations on lists, making it
very useful for append-heavy uses (esp. left-nested uses of `++`

), such
as logging and pretty printing.

Here is an example using DList as the state type when printing a tree with the Writer monad:

import Control.Monad.Writer import Data.DList data Tree a = Leaf a | Branch (Tree a) (Tree a) flatten_writer :: Tree x -> DList x flatten_writer = snd . runWriter . flatten where flatten (Leaf x) = tell (singleton x) flatten (Branch x y) = flatten x >> flatten y

# Construction

apply :: DList a -> [a] -> [a]Source

Apply a dlist to a list to get the underlying list with an extension

apply (fromList xs) ys = xs ++ ys