User:Ezrakilty/Draft of Anamorphism

In functional programming, an anamorphism is a kind of generic function which can (co)recursively construct a result of a certain type and which is parameterized by functions that determining what the next single step of the construction is. The term comes from Greek ἀνά (upwards) + morphism (from Greek μορφή, or form, shape) and the concept has its grounding in Category theory.

The concept of anamorphism generalizes the list-producing unfold functions to arbitrary algebraic data types that can be described as final coalgebras. In fact, the terms 'anamorphism' and "unfold" (as a noun) are often used interchangeably. Anamorphisms, which are co-recursive, are dual to catamorphisms, which are recursive, just as unfolds are dual to folds.

= Examples =

= Anamorphisms on Lists =

An unfold on lists would build a (potentially infinite) list from a seed value. Typically, the unfold takes a seed value, a one-place operation   that yields a pairs of such items, and a predicate   which determines when to finish the list (if ever). In the action of unfold, the first application of, to the seed  , would yield. The list defined by the unfold would then begin with  and be followed with the (potentially infinite) list that unfolds from the second term, , with the same operations. So if, then the list will begin  , where   is the result of unfolding v with r, and so on.

A Haskell definition of an unfold, or anamorphism for lists, called, is as follows:

-- The type signature of 'ana': ana :: (b->(a,b)) -> (b->Bool)-> b -> [a] -- Its definition: ana unspool finished x = if finished x                        then [] else a : ana unspool finished y                            where (a,y) = unspool x

(Here  and   are parameters of the function, like  .) We can now implement quite general functions using ana.

Anamorphisms on other data structures
An anamorphism can be defined for any recursive type, according to a generic pattern. For example, the unfold for the tree data structure

data Tree a = Leaf a | Branch Tree a Tree

is as follows

ana :: (b->Either a (b,a,b)) -> b -> Tree a ana unspool x = case unspool x of                  Left a -> Leaf a                   Right (l,x,r) -> Branch (ana unspool l) x (ana unspool r)

= History =

One of the first publications to introduce the notion of an anamorphism in the context of programming was the paper Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire, by Erik Meijer et al., which was in the context of the Squiggol programming language.

Applications
Functions like  and   are examples of anamorphisms. takes a pair of lists, say ['a','b','c'] and [1,2,3] and returns a list of pairs [('a',1),('b',2),('c',3)]. takes a thing, x, and a function, f, from such things to such things, and returns the infinite list that comes from repeated application of f, i.e. the list [x, (f x), (f (f x)), (f (f (f x))), ...].

To prove this, we can implement both using our generic unfold,, using a simple recursive routine:

zip2 = ana g p   where p (as,bs) = (as==[]) || (bs ==[]) g ((a:as), (b:bs)) = ((a,b),(as,bs))

iterate2 f = ana (\a->(a,f a)) (\x->False) Ruby comes with an explicit unfold operation; so, for example: 10.unfold { |n| n-1 unless n == 1 }.inspect => [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

10.class.unfold(&:superclass).inspect => [Fixnum, Integer, Numeric, Object]

In a language like Haskell, by contrast, even the abstract functions,   and   are merely defined terms, as we have seen from the definitions given above.

Anamorphisms in category theory
In category theory, anamorphisms are the categorical dual of catamorphisms.

Notation
A notation for ana f found in the literature is $$[\!(f)\!]$$. The brackets used are known as lens brackets, after which anamorphisms are sometimes referred to as lenses.