## 2009-12-24

### Functional Macramé

What is the meaning of an expression like

```let rec e = f … e …
```

known Haskell is as "knot-tying"? As Lloyd Allison explains:

A circular program creates a data structure whose computation depends upon itself or refers to itself. The technique is used to implement the classic data structures circular and doubly-linked lists, threaded trees and queues, in a functional programming language. These structures are normally thought to require updatable variables found in imperative languages…

But first, a bit of motivation. OCaml allows for the construction of cyclic values going through a data constructor. For instance, the following is legal:

```let rec ones = 1 :: ones in ones
```

as the expression is a `cons` cell. This can be extended naturally to mutually recursive values. For instance, a grammar can be built with:

```type 'a symbol = Terminal of 'a | Nonterminal of 'a symbol list list

let arith_grammar =
let rec s  = Nonterminal [[add]]
and mul    = Nonterminal [[term]; [mul; Terminal "*"; term]]
and term   = Nonterminal [[number]; [Terminal "("; s; Terminal ")"]]
and number = Nonterminal [[digit]; [digit; number]]
and digit  = Nonterminal (List.map (fun d -> [Terminal (string_of_int d)]) (range 0 9))
in s
```

This is a perfectly valid recursive value in OCaml and it is a direct translation from the code in this article. The problem is that an implementation of the `Omega` monad for breadth-first enumeration of a list of lists requires laziness in an essential way. I'll use a stub (mock?) sequence type:

```module Seq = struct
type 'a cons = Nil | Cons of 'a * 'a t
and 'a t  = 'a cons Lazy.t
let rec map f q = lazy (match Lazy.force q with
| Nil -> Nil
| Cons (x, q) -> Cons (f x, map f q))
let rec of_list l = lazy (match l with
| [] -> Nil
| x :: xs -> Cons (x, of_list xs))
end
```

Unfortunately this doesn't work:

```type 'a symbol = Terminal of 'a | Nonterminal of 'a symbol Seq.t Seq.t

let rule ss = Nonterminal (Seq.map Seq.of_list (Seq.of_list ss))

let arith_grammar =
let rec s  = rule [[add]]
and mul    = rule [[term]; [mul; Terminal "*"; term]]
and term   = rule [[number]; [Terminal "("; s; Terminal ")"]]
and number = rule [[digit]; [digit; number]]
and digit  = rule (List.map (fun d -> [Terminal (string_of_int d)]) (range 0 9))
in s
```

The dreaded `"This kind of expression is not allowed as right-hand side of `let rec'"` error raises its ugly head: `rule` is a function, not a constructor, and OCaml rightly complains that it cannot lazily evaluate a bunch of strict definitions involving computation. In a lazy language, in contrast, the right-hand-side expression is not evaluated until it is needed. So, again, what is the meaning of an expression like

```let rec e = f … e …
```

When the value of e is required, the function f is called with an unevaluated e. If it doesn't use it, the result is well-defined; if it does, this results in a recursive call to f. In a strict language we must be explicit in the delaying and forcing of thunks:

```let f' … e … =
…
if e_is_needed then … Lazy.force e …
…
in
let rec e = lazy (f' … e …)
```

Alas, if f' itself is lazy, the expected code won't work:

```let f' … e … = lazy (
…
if e_is_needed then … Lazy.force e …
…
)
in
let rec e = f' … e …
```

because `lazy` works syntactically as a constructor in OCaml, again we're told that `"This kind of expression is not allowed as right-hand side of `let rec'"`. This means that we cannot use knot-tying with lazy abstract data types like infinite lists and streams without going explicitly through `lazy`.

Stepping back and taking a little distance from the problem at hand, let's revisit Allison example of circular lists. He gives essentially this example:

```let circ p f g x =
let rec c = build x
and build y = f y :: if p y then c else build (g y)
in c
```

(which is equivalent to an `unfold` followed by a knot-tying). This unsurprisingly doesn't work, but using `lazy` as outlined above does:

```let circ p f g x =
let rec c = lazy (build x)
and build y = Seq.Cons (f y, if p y then c else lazy (build (g y)))
in c
```

and the knot is tied by actually making a reference to the value as desired:

```let x = circ (fun _ -> true) id id 0 in let Seq.Cons (_, y) = Lazy.force x in x == y ;;
- : bool = true
```

A bit of lambda-lifting to make the binding and value recursion distinct and separate gives:

```let circ p f g x =
let rec build y c = Seq.Cons (f y, if p y then c else lazy (build (g y) c)) in
let rec c = lazy (build x c) in c
```

This hints at what appears to be a limitation of strict languages, namely that circular computations seem to require explicit binding management in an essential way, either imperative like in this code or by using a method like Dan Piponi's Löb functor. Applying this technique to our grammar makes for tedious work: all the mutually recursive references must be lambda-lifted, and the knot tied simultaneously through `lazy`:

```let rule ss = Lazy.force (Seq.map Seq.of_list (Seq.of_list ss))

let arith_grammar =
and make_mul    exp add mul trm num dig = rule [[trm]; [mul; Terminal "*"; trm]]
and make_term   exp add mul trm num dig = rule [[num]; [Terminal "("; exp; Terminal ")"]]
and make_number exp add mul trm num dig = rule [[dig]; [dig; num]]
and make_digit  exp add mul trm num dig = rule (List.map (fun d -> [Terminal (string_of_int d)]) (range 0 9))
in let
rec exp = Nonterminal (lazy (make_expr   exp add mul trm num dig))
and mul = Nonterminal (lazy (make_mul    exp add mul trm num dig))
and trm = Nonterminal (lazy (make_term   exp add mul trm num dig))
and num = Nonterminal (lazy (make_number exp add mul trm num dig))
and dig = Nonterminal (lazy (make_digit  exp add mul trm num dig)) in
exp
```

This can become unworkable pretty quickly, but is a solution! Note that the type of sequences forces me to use an explicit evaluation discipline: `rule` must return an evaluated expression, but the evaluation itself is delayed inside the `Nonterminal` constructor.

Allison's paper ends with an alternative for strict imperative languages like Pascal: using an explicit reference for the circular structure, something like this:

```let f' … e … =
…
if e_is_needed then … Ref.get e …
…
in
let e_ref = Ref.make () in
let e = f' … e_ref … in
Ref.set e_ref e
```

where `Ref.make` has type `unit -> 'a`, that is, it is magic. Unfortunately, Xavier Leroy himself stated that `Obj.magic` is not part of the OCaml language :-) (although a quick look shows many a would-be apprentice at work). And in this case it is true that no amount of magic wold make this work in the general case since `e_ref` must refer to an otherwise dummy value of the appropriate type which gets overwritten with the final result, in effect reserving memory of the necessary size. In specific cases, however, this can be made to work with a bit of care.

Merry Christmas!

## 2009-12-23

### Gained in Translation

First of all, I'd like to apologize for the infrequent updates and the lightness of the last few entries. I seldom have time of late for anything but the quickest of finger exercises, but I wanted to put something on writing before the year is over. What better inspiration than one of Remco Niemeijer's terse solutions to the daily Programming Praxis. This week's asks for an implementation of Parnas's permuted indices, and Remco's solution is minimal enough. I translated his Haskell code to almost-verbatim OCaml, interjecting the necessary definitions to make the code read essencially the same way. For example, I needed to translate:

```rot xs = [(unwords a, unwords b) | (a, b) <- init \$
zip (inits xs) (tails xs), notElem (head b) stopList]
```

(n.b: this is Haskell). The function `inits` returns all the initial segments of a list, so that `inits "abc" = ["", "a", "ab", "abc"]`. Conversely, `tails` returns all the tails of a list, so that `tails "abc" = ["abc", "bc", "c", ""]`. The `zip` of both lists is the list of all the ways in which you can split a list, so that with our example:

```zip (inits "abc") (tails "abc") = [
("", "abc"),
("a", "bc"),
("ab", "c"),
("abc", "")
]
```

and the `init` of that is every element on that list except for the last one. After writing the necessary infrastructure, the equivalent solution was simple to write, but then I noticed that I could refactor it into something a bit terser. The first opportunity for compression I found was to use an ad-hoc function for splitting a list in every way possible except the last, in effect subsuming `init \$ zip (inits xs) (tails xs)` into a single recursive function:

```let rec split_all l = match l with
| []      -> []
| x :: xs -> ([], l) :: List.map (fun (hs, ts) -> x :: hs, ts) (split_all xs)
```

Classic of text processing tasks in Haskell is the use of functions converting text into lists and vice versa; this required writing some simple helper functions:

```let words = Str.split (Str.regexp " ")
and lines = Str.split (Str.regexp "\n")
and unwords = String.concat " "
```

The permuted index construction must filter a number of stop words:

```let stop_list = words "a an and by for if in is of on the to"
```

As Remco explains, the core function for generating a permuted index finds all the splittings of a given sentence, and uses the head as the context for the tail. The function he gives is a typical generation—filtering—reduction pipeline expressed as a list comprehension. I initally wrote the comprehension as a right fold (this is always possible), and in a second phase I rewrote that into a point-free function more directly expressing the reduction. For that I needed a number of combinators:

```let ( % ) f g x = f (g x)

let cross f (x, y) = (f x, f y)

let distrib f (x, y) (z, t) = (f x z, f y t)

let flip f x y = f y x
```

The composition operator `%` is an old friend of this blog. The combinator `cross` lifts a function over a pair, and `distrib` distributes a binary function over two pairs. The combinator `flip` swaps the arguments to a curried function. All of this is standard and it allowed me to write:

```let rot = List.map (cross unwords) % List.filter (not % flip List.mem stop_list % List.hd % snd) % split_all
```

This function takes a list of words, splits it every which way, throws away those pairs whose second component (the tail) begins with a stop word, and joins each component of the resulting pairs of words into sentence fragments. The function pretty-printing an index underwent a similar compression: instead of finding the longest fragment separately on each component, I did it in one pass over the list of pairs:

```let pp_index xs =
let l1, l2 = List.fold_right (distrib (max % String.length)) xs (0, 0) in
List.iter (fun (a, b) -> Printf.printf "%*s   %-*s\n" l1 a l2 b) xs
```

The function `max % String.length` composes on the first argument of the curried `max`, and thus has type `string → int → int`; in order to distribute over pairs and make the types come out right I needed to use a `right_fold` instead of a more natural (in OCaml) `left_fold`, but this is otherwise straightforward. The pretty printing of the index is exactly like in Remco's code, as both OCaml's and Haskell's `printf` implement the same formats. Putting everything together needs a sort on the second components; I use a (very inefficient) helper function implementing case-insensitive sort:

```let ci_compare a b = compare (String.lowercase a) (String.lowercase b)

let permute_index =
pp_index % List.sort (fun (_, a) (_, b) -> ci_compare a b) % List.concat % List.map (rot % words) % lines
```

The text is decomposed into lines, each line is further decomposed into words and an index is built for it, the fragmentary indexes are collated and sorted into the final result which is finally printed out. A test gives out the expected result:

```let () = permute_index "All's well that ends well.\nNature abhors a vacuum.\nEvery man has a price.\n"
Nature   abhors a vacuum.
All's well that ends well.
All's well that   ends well.
Every man has a price.
Every man   has a price.
Every   man has a price.
Nature abhors a vacuum.
Every man has a   price.
All's well   that ends well.
Nature abhors a   vacuum.
All's   well that ends well.
All's well that ends   well.
```

A point to keep in mind is that `permute_index` and especially `rot` would probably have been clearer written in a monadic style, as it emphasizes an "element-at-a-time" view of list processing as I've written before. The downside would have been the need to name every intermediate value being transformed:

```let rot xs =
split_all xs >>= fun (hs, ts) ->
guard (not (List.mem (List.hd ts) stop_list)) >>
return (unwords hs, unwords ts)
```

It seems that, in this sense, monadic beats recursion but point-free beats monadic for conciseness. As it is, the 30 lines comprising this code fit in one short page. Not bad.