`map`

over a `List`

. Here's the implementation in F# let map converter l = let rec loop acc = function | [] -> acc | hd :: tl -> loop (converter hd :: acc) tl List.rev (loop [] l)

Scala is also a statically typed functional programming language, though it uses a completely different trick and mutability to implement

`map `

over a sequence. Let's ignore it for the time being and imagine we are being a bonafide functional programmer.The above code uses a very common idiom of accumulate-and-reverse to implement a tail recursive algorithm. Though Scala stdlib does not use this technique and uses a mutable construct for this implementation, we could have done the same thing in Scala as well ..

Both Scala and F# are languages with strict evaluation semantics as the default. What would a similar tail recursive Haskell implementation look like ?

map' f xs = reverse $ go [] xs where go accum [] = accum go accum (x:xs) = go (f x : accum) xs

Let's now have a look at the actual implementation of

`map`

in Haskell prelude ..map :: (a -> b) -> [a] -> [b] map _ [] = [] map f (x:xs) = f x : map f xs

Whoa! It's not a tail recursion and instead a body recursive implementation. Why is that ? We have been taught that tail recursion is the holy grail since it takes constant stack space and all ..

In a strict language the above implementation of

`map`

will be a bad idea since it uses linear stack space. On the other hand the initial implementation is tail recursive. But Haskell has non-strict semantics and hence the last version of map consumes only one element of the input and yields one element of the output. The earlier versions consume the whole input before yielding any output.In a lazy language what you need is to make your algorithm co-recursive. And this needs co-data. Understanding co-data or co-recursion needs a brief background of

*co-induction*and how it differs from

*induction*.

When we define a list in Haskell as

data [a] = [] | a : [a]

it means that the set "List of a" is the

*smallest*set such that [] is in the List of a, and if [a] is in the List of a and a is in a, then a : [a] is in List of a. This is the inductive definition os a List and we can use recursion to implement various properties of a List. Also once we have a recursive definition, we can use structural induction to prove various properties of the data structure.

If an inductive definition on data gives us the smallest set, a co-inductive definition on co-data gives us the largest set. Let's define a Stream in Haskell ..

data Stream a = Cons a (Stream a)

First to note - unlike the definition of a

`List`

, there's no special case for empty `Stream`

. Hence no base case unlike the inductive definition above. And a "Stream of a" is the *largest*set consisting of a pair of an "a" and a "Stream of a". Which means that

`Stream`

is an infinite data structure i.e. the range (or co-domain) of a Stream is infinite. And we implement properties on co-inductive data structures using co-recursive programs. A co-recursive program is defined as one whose range is a type defined recursively as the greatest solution of some equation.In terms of a little bit of mathematical concepts, if we model types as sets, then an infinite list of integers is the

*greatest*set X for which there is a bijection X ≅ ℤ x X and a program that

*generates*such a list is a co-recursive program. As its dual, the type of a finite list is the

*least*set X for which X ≅ 1 + (ℤ x X), where 1 is a singleton set and + is the disjoint union of sets. Any program which

*consumes*such an input is a recursive program. (Note the dualities in italics).

Strictly speaking, the co-domain does not necessarily have to be infinite. If you have read my earlier post on initial algebra, co-recursion recursively defines functions whose co-domain is a

*final data type*, dual to the way that ordinary recursion recursively defines functions whose domain is an

*initial data type*.

In case of primitive recursion (with the

`List`

data type above), you always frame the recursive step to operate on data which gets reduced in size in subsequent steps of recursive calls. It's not so with co-recursion since you may be working with co-data and infinite data structures. Since in Haskell, a `List`

can also be infinite, using the above co-recursive definition of `map`

, we can havehead $ map (1+) [1..]

which invokes

`map`

on an infinite list of integers. And here the co-recursive steps of map operate successively on sets of data which are not less than the earlier set. So, it's not tail recursion that makes an efficient implementation in Haskell, you need to make the co-recursive call within the application of a constructor.As the first post of the new year, that's all friends. Consider this as the notes from someone learning the principles of co-inductive definitions. Who knew co-recursion is so interesting ? It will be more interesting once we get down into the proof techniques for co-recursive programs. But that's for a future post ..

## 1 comment:

There's a discussion going on here:

http://redd.it/163vi2

Post a Comment