We use cookies and other tracking technologies to improve your browsing experience on our site, analyze site traffic, and understand where our audience is coming from. To find out more, please read our privacy policy.

By choosing 'I Accept', you consent to our use of cookies and other tracking technologies.

We use cookies and other tracking technologies to improve your browsing experience on our site, analyze site traffic, and understand where our audience is coming from. To find out more, please read our privacy policy.

By choosing 'I Accept', you consent to our use of cookies and other tracking technologies. Less

We use cookies and other tracking technologies... More

Login or register
to apply for this job!

Login or register to start contributing with an article!

Login or register
to see more jobs from this company!

Login or register
to boost this post!

Show some love to the author of this blog by giving their post some rocket fuel πŸš€.

Login or register to search for your ideal job!

Login or register to start working on this issue!

Engineers who find a new job through Functional Works average a 15% increase in salary πŸš€

Blog hero image

Programming with Bananas in OCaml

Marty Stumpf 23 January, 2019 (4 min read)

By bananas, I mean banana brackets as in the famous paper "Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire" by Meijer et al. In this post I only focus on bananas, also called catamorphisms.

Recursion is core to functional programming. Meijer et al. show that we can treat recursions as separate higher order functions known as recursion schemes. Catamorphisms is one type of recursion schemes.

Why Should I Care?

Because knowing how to use recursion schemes improves your coding ability! Consider a simple exercise: finding the minimum element of an array. In OCaml, without using fold (catamorphisms), we would compare the elements of the array a one by one, keeping the minimum of the element, until we reach the end of the array. E.g.:

let rec find_min_inner a i j =
  match a.(i) > a.(j) , (Array.length a -1 < i || Array.length a - 1 < j + 1) with
  |true, true -> a.(j)
  |false, true -> a.(i)
  |true, false -> find_min_inner a j (j + 1)
  |false, false -> find_min_inner a i (j + 1) ;;
let find_min a =
  match a with
  |[||] -> [||]
  |_ -> find_min_inner a 0 1 ;;

Using catamorphisms or foldleft (or foldright) in OCaml, we can do the equivalent for int arrays in one line:

let find_min a =
Array.fold_left (fun x y -> if x < y then x else y) max_int a;;

Or, using the function min in the Pervasives to replace the anonymous function and eta-reducting a:

let find_min = Array.fold_left min max_int;;

Catamorphisms dramatically reduce the amount of code because foldleft does exactly what we want to do for us: recurse down each element of the array. Of course, foldleft or fold_right work on other data structures too.

How Does It Work?

Going back to the above example, what's going on in that one line? We invoke the iterator in the array module foldleft. foldleft has the following type signature:

('a -> 'b -> 'a) -> 'a -> 'b array -> 'a

That is, fold_left takes 3 inputs:

  • A function that takes two arguments, one of type 'a and one of type that is the same as the array, and returns a result of type 'a.
  • An input of type 'a, think of it as the base case of the recursion.
  • An array (of the same or different type to 'a).

The output of fold_left is of type 'a.

The first input is a function that does something with the first input (of type 'a) and an element of the array. In this example, the function is min and it compares max_int with an element of the array.

foldleft recurses the function with the earlier result as an input. In this example, foldleft calls the following:

(* When the array is empty, it returns the max_int. *)
fold_left min max_int [||] => max_int
(* When the array has one element, it returns the min of max_int and the element. *)
fold_left min max_int [|e1|] => min max_int e1 
(* When the array has two elements, min takes the result of 
(min max_int e1) as an input, and compare it with e2. *)
fold_left min max_int [|e1;e2|] => min (min max_int e1) e2     
(* When the array has three elements, min takes the result of 
fold_left max_int [|e1;e2|] as an input, and compare it with e3. *)
fold_left min max_int [|e1;e2;e3|] => min (min (min max_int e1) e2) e3 

We can generalize it to any function f, with x as the base case and a as the array input, the result is as in the Pervasives:

fold_left f x a => f a (... (f (f x a.(0)) a.(1)) ...) a.(n-1)

fold_right works similarly, except that the array elements are the first input to the function, and the brackets are to the right:

(* When the array has one element, it returns the min of max_int and the element. *) 
fold_right min [|e1|] max_int => min e1 max_int
(* When the array has two elements, min takes the result of 
(min e2 max_int) as an input, and compare it with e1. *)
fold_right min [|e1;e2|] max_int => min e1 (min e2 max_int)
(* When the array has three elements, min takes the result of 
(min e3 max_int) as an input to compare with e2,
the result of which is then compared to e1. *)
fold_left min max_int [|e1;e2;e3|] => min e1 (min e2 (min e3 max_in)) 
...

The Base Case

You can see from the above example that to find the minimum element of an array, we can use foldleft or foldright in OCaml, naturally with the min function as the function input. But how do we choose the base case?

The base case is there to safe guard an empty array input. When an empty array is input to foldleft or foldright, OCaml returns the base case. Otherwise, the base case must have the property that when the function takes the base case and another input, the function returns the other input as a result. That is, **given x is the base case, f x e must return e***. In the above example, because maxint is the maximum integer, min (anything) maxint returns (anything)*, as desired. Other examples are:

let sum = Array.fold_left (+) 0;;
 # sum [||];;
  • : int = 0 (* Passing an empty array to sum returns the base case 0. *) let product = Array.fold_left (fun x y -> x * y) 1;; # product [||];;
    • : int = 1 (* Passing an empty array to product returns the base case 1. *)
Because the base case is just to safe guard an empty input, when you can be sure that the input is not empty, the base case would not be necessary! OCaml does not provide such option but Haskell does. We'll see this in the next post!

Originally published on thealmarty.com