A quick look at functors in OCaml

A couple of weeks ago I was working on a small program that required generating code in different ways depending on a user option. I was trying to make as few changes as possible. Because of the way the program was created and the language it was written in (not OCaml), it required changing several places in the code.

OCaml functors

I remembered reading a little bit about the concept of a functor in OCaml. Functors are a powerful mechanism that allow you to create modules parameterized by modules. In the case of the task I was working on, I can use it to write the code generation section using module parameterized by a module that provides the final implementation of the code generation.

The example: Code generation via method calls or operators

I’m going to use a simple example of using a functor. Say that we have a representation for a very simple language:

(* ast.ml *)
type expr =
        | Plus of expr * expr
        | Minus of expr * expr
        | Div of expr * expr
        | Times of expr * expr
        | Call of expr * (expr list)
        | Var of string
        | Dot of expr * string

I want to have the posibility of generating arithmetic expressions in this language in two ways:

1. Generating method calls of arithmetic operations for a Java-like language
2. Generate common operators

One example of option #1 is:

var1.multiply(10).plus(var2)

For option #2 is:

var1 * 10 + var2

The code that generates the expressions must not be aware of the strategy that we are using to generate the code. To do this in OCaml we define a signature for the module used to generate the code:

module type GeneratorFuncs = sig
    val (+) :  Ast.expr -> Ast.expr -> Ast.expr
    val (-) : Ast.expr -> Ast.expr -> Ast.expr
    val (/) : Ast.expr -> Ast.expr -> Ast.expr
    val ( * ) : Ast.expr -> Ast.expr -> Ast.expr
end

We use operators to make it easy to write the code generation. The module that makes the code generator is written as a functor with a parameter that is the module which implements the GeneratorFuncs signature.

The following code shows the “generator” which generates random arithmetic expressions using the provided module for emitting the code:

module Make_generator(Current_funcs : GeneratorFuncs) = struct
  let gen_single() = 
        if Random.int 10 > 5 then
           Ast.Var "x"
        else 
           Ast.Lit (1 + Random.int 5)


  let rec generate_sample (depth: int) =  
    let new_depth = depth - 1 in
    Current_funcs.(
        match depth, Random.int 10 with
        | 0, _ -> gen_single()
        | _, r when r >= 0 && r <= 3 -> 
              ((generate_sample new_depth) + (generate_sample new_depth))
        | _, r when r >= 4 && r <= 6 -> 
              ((generate_sample new_depth) - (generate_sample new_depth))
        | _, r when r >= 7 && r <= 10 -> 
              ((generate_sample new_depth) / (generate_sample new_depth))
        | _, _ -> Ast.Var "x")
end

We can write our emitter for generating code using method calls like this:

(* mgenerator.ml *)
module MGenerator = struct
        let simple_call (obj: Ast.expr) mmethod arg =
                Ast.Call(
                        Ast.Dot(
                                obj, 
                                mmethod), [arg])
        let (+) (a: Ast.expr) (b: Ast.expr) = simple_call a "plus" b
        let ( * ) a b = simple_call a "times" b
        let (-) a b = simple_call a "minus" b
        let (/) a b = simple_call a "div" b
end

module MGen = Generator.Make_generator(MGenerator)

An alternative module that generates arithmetic expression using operators:

module OGenerator = struct
        let (+) (a: Ast.expr) (b: Ast.expr) = Ast.Plus(a, b)
        let ( * ) a b = Ast.Times(a, b)
        let (-) a b = Ast.Minus(a, b)
        let (/) a b = Ast.Div(a, b)
end

module OGen = Generator.Make_generator(OGenerator)

We can use this modules to generate sample code snippets:

let main = 
        let _ = Random.self_init() in
        in let generat = Mgenerator.MGen.generate_sample 3 
        in let generat2 = Ogenerator.OGen.generate_sample 3 
        in  
           print_endline (Ast.pprint_string generat);
           print_endline (Ast.pprint_string generat2)

Output:

x.plus(2).plus(5.div(4)).div(x.plus(x).plus(5.div(1)))
x + 4 / x - 2 + 4 + x + 5 + x

Haskell 'newtype' and the record syntax

While reading some Haskell code snippets I found something that seemed confusing. The snippet involved newtype and record syntax. A simplified example is the following:

newtype PersonName = PersonName { theName :: String }
...
let p1 = PersonName $ getName obj
in print $ theName

I was not able to find a place where the PersonName was created by specifying the value of theName explicitly for example (Person { theName = "xyz" }) . The reason is that record syntax allows an alternative way of specifying the field values. For example:

let p1 = PersonName "Luis" -- valid!
...
let p2 = PersonName { theName = "Luis" }  -- valid!

Another thing that I found interesting is the newtype restrictions. For example it only allows you to specify one field in our record:

newtype PersonName' = PersonName' { firstName :: String, lastName ::String }

Compiling this is going to generate the following error:

newtypeexp.hs:6:23: error:
    • The constructor of a newtype must have exactly one field
        but ‘PersonName'’ has two
    • In the definition of data constructor ‘PersonName'’
      In the newtype declaration for ‘PersonName'’
  |
6 | newtype PersonName' = PersonName' { firstName :: String, lastName ::String }
  |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

This seems to be related to the fact that newtype is used as a compile-type concept only. More info here https://wiki.haskell.org/Newtype#The_short_version .