treefold-0.1.0.0: Provides folds which try to combine elements in a balanced way.

Data.TreeFold

Description

This module provides folds which try to combine elements in a balanced way. These can be useful for constructing balanced binary trees, or more stable summation.

For a strict version see Data.TreeFold.Strict.

Synopsis

# Documentation

>>> :{
data Tree a = Empty
| Leaf a
| Tree a :*: Tree a
deriving Show
:}


treeFold :: (a -> a -> a) -> a -> [a] -> a Source #

Reduces a list of values using a binary operation, trying as much as possible to balance. For instance, given the above binary tree type, the operation:

>>> (treeFold (:*:) Empty . map Leaf) [1,2,3,4]
(Leaf 1 :*: Leaf 2) :*: (Leaf 3 :*: Leaf 4)


Will construct a balanced binary tree, whereas the equivalent using a normal fold:

>>> foldr ((:*:) . Leaf) Empty [1,2,3,4]
Leaf 1 :*: (Leaf 2 :*: (Leaf 3 :*: (Leaf 4 :*: Empty)))


Will construct a right-heavy tree.

>>> (treeFold (:*:) Empty . map Leaf) [1,2,3,4,5]
((Leaf 1 :*: Leaf 2) :*: (Leaf 3 :*: Leaf 4)) :*: Leaf 5


Other uses for this function include more stable floating-point summation. The following sum algorithm:

>>> treeFold (+) 0 (replicate 10 9.9)
99.0


Will have O(log n) error growth for summing n numbers, in comparison to O(n) for:

>>> sum (replicate 10 9.9)
99.00000000000001


For a strict version of this function see treeFold.

treeFoldMap :: (b -> a) -> (a -> a -> a) -> a -> [b] -> a Source #

Perform a tree fold after a map.

>>> treeFoldMap Leaf (:*:) Empty [1,2,3,4]
(Leaf 1 :*: Leaf 2) :*: (Leaf 3 :*: Leaf 4)


For a strict version of this function see treeFoldMap.

pairFold :: (a -> a -> a) -> [a] -> [a] Source #

Apply a combining function to pairs in a list.

>>> pairFold (++) ["a","b","c","d","e"]
["ab","cd","e"]


For a strict version of this function see pairFold.

pairFoldMap :: (b -> a) -> (a -> a -> a) -> [b] -> [a] Source #

Apply a combining function to pairs in a list, after a map.

>>> pairFoldMap (:[]) (++) "abcde"
["ab","cd","e"]


For a strict version of this function see pairFoldMap.

treeFoldNonEmpty :: (a -> a -> a) -> NonEmpty a -> a Source #

Perform a tree fold on a non empty input. For a strict version of this function see treeFoldNonEmpty.

treeFoldMapNonEmpty :: (b -> a) -> (a -> a -> a) -> NonEmpty b -> a Source #

Perform a tree fold after a map on non-empty input. For a strict version of this function see treeFoldMapNonEmpty.