Data.DList

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

Documentation

data DList a

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

Instances

Monad DList

Methods

(>>=) :: DList a -> (a -> DList b) -> DList b

(>>) :: DList a -> DList b -> DList b

return :: a -> DList a

fail :: String -> DList a

Functor DList

Methods

fmap :: (a -> b) -> DList a -> DList b

(<$) :: a -> DList b -> DList a

Applicative DList

Methods

pure :: a -> DList a

(<*>) :: DList (a -> b) -> DList a -> DList b

(*>) :: DList a -> DList b -> DList b

(<*) :: DList a -> DList b -> DList a

Foldable DList

Methods

fold :: Monoid m => DList m -> m

foldMap :: Monoid m => (a -> m) -> DList a -> m

foldr :: (a -> b -> b) -> b -> DList a -> b

foldr' :: (a -> b -> b) -> b -> DList a -> b

foldl :: (b -> a -> b) -> b -> DList a -> b

foldl' :: (b -> a -> b) -> b -> DList a -> b

foldr1 :: (a -> a -> a) -> DList a -> a

foldl1 :: (a -> a -> a) -> DList a -> a

toList :: DList a -> [a]

null :: DList a -> Bool

length :: DList a -> Int

elem :: Eq a => a -> DList a -> Bool

maximum :: Ord a => DList a -> a

minimum :: Ord a => DList a -> a

sum :: Num a => DList a -> a

product :: Num a => DList a -> a

Alternative DList

Methods

empty :: DList a

(<|>) :: DList a -> DList a -> DList a

some :: DList a -> DList [a]

many :: DList a -> DList [a]

MonadPlus DList

Methods

mzero :: DList a

mplus :: DList a -> DList a -> DList a

IsList (DList a)

Associated Types

type Item (DList a) :: *

Methods

fromList :: [Item (DList a)] -> DList a

fromListN :: Int -> [Item (DList a)] -> DList a

toList :: DList a -> [Item (DList a)]

Eq a => Eq (DList a)

Methods

(==) :: DList a -> DList a -> Bool

(/=) :: DList a -> DList a -> Bool

Ord a => Ord (DList a)

Methods

compare :: DList a -> DList a -> Ordering

(<) :: DList a -> DList a -> Bool

(<=) :: DList a -> DList a -> Bool

(>) :: DList a -> DList a -> Bool

(>=) :: DList a -> DList a -> Bool

max :: DList a -> DList a -> DList a

min :: DList a -> DList a -> DList a

Read a => Read (DList a)

Methods

readsPrec :: Int -> ReadS (DList a)

readList :: ReadS [DList a]

readPrec :: ReadPrec (DList a)

readListPrec :: ReadPrec [DList a]

Show a => Show (DList a)

Methods

showsPrec :: Int -> DList a -> ShowS

show :: DList a -> String

showList :: [DList a] -> ShowS

(~) * a Char => IsString (DList a)

Methods

fromString :: String -> DList a

Semigroup (DList a)

Methods

(<>) :: DList a -> DList a -> DList a

sconcat :: NonEmpty (DList a) -> DList a

stimes :: Integral b => b -> DList a -> DList a

Monoid (DList a)

Methods

mempty :: DList a

mappend :: DList a -> DList a -> DList a

mconcat :: [DList a] -> DList a

NFData a => NFData (DList a)

Methods

rnf :: DList a -> ()

type Item (DList a)

type Item (DList a) = a

Construction

fromList :: [a] -> DList a

Convert a list to a dlist

toList :: DList a -> [a]

Convert a dlist to a list

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

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

apply (fromList xs) ys = xs ++ ys

Basic functions

empty :: DList a

Create a dlist containing no elements

singleton :: a -> DList a

Create dlist with a single element

cons :: a -> DList a -> DList a infixr 9

O(1). Prepend a single element to a dlist

snoc :: DList a -> a -> DList a infixl 9

O(1). Append a single element to a dlist

append :: DList a -> DList a -> DList a

O(1). Append dlists

concat :: [DList a] -> DList a

O(spine). Concatenate dlists

replicate :: Int -> a -> DList a

O(n). Create a dlist of the given number of elements

list :: b -> (a -> DList a -> b) -> DList a -> b

O(n). List elimination for dlists

head :: DList a -> a

O(n). Return the head of the dlist

tail :: DList a -> DList a

O(n). Return the tail of the dlist

unfoldr :: (b -> Maybe (a, b)) -> b -> DList a

O(n). Unfoldr for dlists

foldr :: (a -> b -> b) -> b -> DList a -> b

O(n). Foldr over difference lists

map :: (a -> b) -> DList a -> DList b

O(n). Map over difference lists.