Fast and reliable programs with OCaml


Article from Issue 163/2014

Static typing, type checking, and low memory usage make this easy-to-learn language a strong candidate for application development.

OCaml is a statically typed programming language with a focus on correctness and speed. First released in 1996 as "Objective Caml," OCaml extended the older Caml language with object-oriented features. OCaml [1] is now mature, stable, and well documented.

It supports both functional and imperative programming styles, making it a good choice for Python, C, or Java programmers interested in writing more reliable software.

Syntax Basics

OCaml's syntax can look a little alien at first. For example, here's a complete OCaml program:

let x = 3
let y = 4
let () =
    "%d + %d = %d\n"
    x y (x + y)

The let declarations are evaluated in order (the compiler infers the types automatically). Expressions that don't return any meaningful value, such as printf, return the empty tuple (), which is called unit, similar to void in C or Java.

Assigning the final result to () causes the compiler to check that the expression really does return unit and you're not ignoring something important. Printf.printf means the printf function inside the Printf module. Module names always start with a capital letter in OCaml.


Functions are also defined with the let keyword:

let add x y = x + y

Unlike C, Python, and Java, OCaml does not use parentheses around arguments and does not have a return keyword; it simply evaluates the function's body as a single expression. In OCaml, even an ifthen construct is an expression and produces a value, as in this factorial definition:

let rec fact n =
  if n = 1 then 1
  else n * fact (n - 1)

When defining a recursive function, such as factorial, you must use the rec keyword to allow the function to call itself. Without this, the name fact wouldn't be in scope within the body.

Partial Functions

OCaml functions really only take a single argument. A two-argument function conceptually takes its first argument and returns a new function to handle the second. This process is known as currying. These expressions are equivalent:

add x y
  (add x) y

For example, add 5 is a function that takes an integer and adds 5 to it:

let add_five = add 5
let six = add_five 1

You'll often see partial application of a curried function to make code more concise. These are equivalent:

let hi x = printf "Hi, %s!\n" x
let hi = printf "Hi, %s!\n"

In both cases, hi is a function with type string -> unit (it takes a string and returns nothing). Partial application is particularly useful with loops. For example, to print each item in a list, you can do:

List.iter (Printf.printf "- %s\n") ["foo"; "bar"]

The first argument to List.iter is a function to be invoked on each item in the list. Partial application saves having to define a new function.

Curried functions allow some useful tricks. Consider the pipe operator, which can be defined as:

let (|>) x f = f x

This takes an argument and a function and calls the function with the argument. It works a bit like a pipe in the shell:

["foo"; "bar"]
|> String.uppercase
|> List.iter
   (Printf.printf "- %s\n") produces a new list by using the given function to transform each item.

This code converts each string to upper case and then prints it. Can you see how it works? Hint: x |> f |> g is interpreted as (x |> f) |> g. The pipe operator can make function chains easier to read, and it's also a built-in operator in later versions of OCaml.

Buy this article as PDF

Express-Checkout as PDF
Price $2.95
(incl. VAT)

Buy Linux Magazine

Get it on Google Play

US / Canada

Get it on Google Play

UK / Australia

Related content

  • Batsh

    Batsh kills two birds with one stone: Programs written in this language can be compiled both as Linux Bash scripts and Windows batch files.

  • Helma

    The powerful Helma application server brings new powers to the JavaScript language. We'll show you how to use Helma to build a simple RSS reader.

  • File Comparison

    With support for more than 60 file formats, diffoscope extends the power of diff beyond the plain text or HTML file.

  • Highlight Learns F#

    The new version of Highlight, the software that highlights numerous program codes in color, supports amongst other languages, F#.

  • Let's Go!

    Released back in 2012, Go flew under the radar for a long time until showcase projects such as Docker pushed its popularity. Today, Go has become the language of choice of many system programmers.

comments powered by Disqus
Subscribe to our Linux Newsletters
Find Linux and Open Source Jobs
Subscribe to our ADMIN Newsletters

Support Our Work

Linux Magazine content is made possible with support from readers like you. Please consider contributing when you’ve found an article to be beneficial.

Learn More