Introduction to functional programming using Ocaml

Introduction to Functional Programming with
Ocaml
Pramode C.E
http://pramode.net

January 30, 2014

Workshop Plan
Here is what we will do:
Learn some Ocaml syntax and write simple Ocaml programs
Learn important concepts like: closures, higher order functions,
purity, lazy vs strict evaluation, currying, tail calls/TCO,
immutability, persistent data structures, type inference etc!
Understand the essence of the "Functional Programming"
paradigm through Ocaml
Not beginner-level stu - but I will try to keep things as simple as
possible!

Pramode C.E

Introduction to Functional Programming with Ocaml

Ocaml - some background info

Written in 1996 by Xavier Leroy and other researchers at
INRIA, France
A member of the ML family
http://en.wikipedia.org/wiki/ML_(programming_language)
Supports Functional, Imperative and Object oriented
programming
A powerful static type system with type inference
Major inuence behind Microsoft F#
Recent developments: the Core standard library (by Jane
Street) and realworldocaml.org

Pramode C.E


Pramode C.E


Where is it being used?

List of companies: http://ocaml.org/learn/companies.html
Facebook - pf, a tool for analysing PHP source
Citrix - Uses Ocaml in XenServer, a virtualization system
Jane Street - develops trading systems in Ocaml
Bloomberg - uses Ocaml for developing nancial derivatives
risk management applications

Pramode C.E


The Ocaml REPL
Invoke the REPL with the utop command at the shell prompt:
utop # print_string hellon;;
hello
- : unit = ()
utop # 2 * 3;;
- : int = 6
utop # let x = 10;;
val x : int = 10
utop # x * 2;;
- : int = 20
utop # let y = 5 in y * 8;;
- : int = 40
utop #

Question: what is the dierence between let and let ... in?
Pramode C.E


Function Denition

let add a b = a + b
let m = add 10 20

We dene add to be a function which accepts two parameters of
type int and returns a value of type int. Similarly, m is dened as a
variable of type int.
But wait ... we haven't actually dened all these types!

Pramode C.E


Type Inference

We have NOT specied the return type of the function or the type
of the variable m. Ocaml infers that (the technical term is HindleyMilner type inference)
This is the type which utop shows us:
val add : int - int - int
Read this as: function takes two int's as arguments and returns an
int.

Pramode C.E


Static vs Dynamic typing

#Python - dynamic typing
def foo(x): return x/2
/* C - static typing with NO type inference */
int foo(int x) { return x / 2; }
(* ML - static typing with type inference *)
let foo x = x / 2

Pramode C.E


Expression Oriented Programming

let i = 0
let p = if (i 0) then -1 else -2
let q = if (true) then hello else world

Unlike languages like C/Java, almost everything in Ocaml is an
expression, ie, something which computes a value! Rather than
programming with statements, we program with expressions.

Pramode C.E


Recursion

(* compute sum of first n numbers *)
let rec sum n =
if (n = 0) then 0 else n + sum (n - 1)
let r = sum 10

Try calling the function sum with a large number (say 1000000)
as parameter! You get a stack overow!

Pramode C.E


Tail Calls and TCO

(* compute sum of first n numbers *)
let rec sum n acc =
if (n = 0) then acc else sum (n - 1) (acc + n)
let r = sum 10 0

This is a tail-recursive version of the previous function - the
Ocaml compiler converts the tail call to a loop, thereby avoiding
stack overow!

Pramode C.E


Tail Calls and TCO
(sum 4)
(4 + sum 3)
(4 + (3 + sum 2))
(4 + (3 + (2 + sum 1)))
(4 + (3 + (2 + (1 + sum 0))))
(4 + (3 + (2 + (1 + 0))))
(4 + (3 + (2 + 1)))
(4 + (3 + 3))
(4 + 6)
(10)
-----------------------------(sum 4 0)
(sum 3 4)
(sum 2 7)
(sum 1 9)
(sum 0 10)
(10)
Pramode C.E


Parametric polymorphism
let foo x = x

Our function foo is the identity function; it takes in a value and
returns the same! What is the inferred type of this function?
More examples:
let foo x y = x
let foo2 x y = if true then x else y
let foo3 x y = if x then y else y
let foo4 x y = if x then y else x
Pramode C.E


Higher order functions

let double x = 2*x
let triple x = 3*x
let apply f x = f x
let p = apply double 10
let q = apply triple 10

What is type of apply?

Pramode C.E


Summation once again!
let sqr x = x * x
let cube x = x * x * x
let rec sumSimple a b =
if a = b then a else a + sumSimple (a + 1) b
let rec sumSquares a b =
if a = b then (sqr a) else (sqr a) + sumSquares (a + 1) b
let rec sumCubes a b =
if a = b then (cube a) else (cube a) + sumCubes (a + 1) b

Pramode C.E


Summation - a more elegant method

let identity x = x
let sqr x = x * x
let rec sum f a b =
if a = b then (f a) else (f a) + sum f (a + 1) b
let p = sum identity 0 4
let q = sum sqr 0 4
let r = sum cube 0 4

Pramode C.E


Anonymous functions

let apply f x = f x
let p = apply (fun x - 2*x) 10

We can create anonymous functions on-the-y! fun x - 2*x is a
function which takes an x and returns 2*x.

Pramode C.E


Methods on collections: Map/Filter/Reduce
open Core.Std
let a = [1;2;3;4]
let p = List.map a (fun x - x * x)
let q = List.filter a (fun x - (x mod 2) = 0)
let r = List.reduce a (fun x y - x + y)

Map applies a function on all elements of a sequence. Filter selects
a set of values from a sequence based on the boolean value
returned by a function passed as its parameter - both functions
return a new sequence. Reduce combines the elements of a
sequence into a single element.
Pramode C.E


More methods on collections

open Core.Std
let even x = (x mod 2) = 0
let a = [1;2;3;4;5;6;7]
let b = [2;4;6;5;10;11;13;12]
let
let
let
let

c
d
e
f

=
=
=
=

List.for_all a even
List.exists a even
List.take_while a even
List.partition_tf a even

Pramode C.E


Nested functions / functions returning functions

(* foo returns sqr *)
let foo () =
let sqr x = x * x in sqr
let f = foo ()
let g = f 10

Pramode C.E


Lexical Closure

let foo1 x = let foo2 y = x + y in foo2
let f = foo1 10
let r = f 20

Pramode C.E


Lexical Closure

The function foo1 returns a closure.
A closure is a function which carries with it references to the
environment in which it was dened.
When we call f(20), the foo2 function gets executed with
the environment it had when it was dened - in this
environment, the value of x is 10.

Pramode C.E


Simple closure examples

let sqr x = x * x
let compose f g = fun x - f (g x)
let f = compose sqr cube
let m = f 2

Pramode C.E


Simple closure examples
open Core.Std
let remove_low_scores xs threshold =
List.filter xs (fun score - score = threshold)
let m = remove_low_scores [20; 35; 80; 92; 40; 98] 50

The anonymous function fun score - score = threshold is
the closure here.
How do you know that it is a closure? Its body uses a variable
threshold which is not in its local environment (the local
environment, in this case, is the parameter list consisting of a
single parameter score)
Pramode C.E


Currying and Partial Application

Here is the denition from Wikipedia:
In mathematics and computer science, currying is the technique of
transforming a function that takes multiple arguments (or a tuple
of arguments) in such a way that it can be called as a chain of
functions, each with a single argument. It was originated by Moses
Schonnkel and later re-discovered by Haskell Curry.

Pramode C.E



let add x y = x + y
let f = add 10
let g = f 20

The type of add is int - int - int. The correct way to read this
is: add takes an int as argument and returns a function which maps
an int to an int.

Pramode C.E



let add x y z = x + y + z
let f = add 10
let g = f 20
let h = g 30

Pramode C.E


Algebraic Data Types - Product types

let a = (1, 2) (* type: int*int *)
let b = (hello, 10, 2) (* type: string*int*int *)

An Algebraic Data Type is a composite type - a type formed by
combining other types. Two classes of algebraic data types are the
product and sum types.

Pramode C.E


Algebraic Data Types - Sum types

type shape =

Circle of int
| Square of int
| Rectangle of (int*int)

let a = Circle 10 (* circle of radius 10 *)
let b = Square 20 (* square with sides 20 *)
let c = Rectangle (5,10) (* rectangle with sides 5 and 10 *)

The type shape describes a shape which can be one of Circle,
Square or Rectangle.

Pramode C.E


Pattern Matching

let a = (1, (2, hello))
let (x, (y, z)) = a

Pattern matching helps you pull apart complex datastructures and
analyse their components in an elegant way (not to be confused
with regular expression based pattern matching which is a
completely dierent thing).

Pramode C.E


Pattern Matching
type shape =

Circle of float
| Square of float
| Rectangle of (float*float)

let area s = match s with
| Circle r - 3.14 *. r *. r
| Square x - x *. x
| Rectangle (x, y) - x *. y
let a = area (Circle 10.0)
let b = area (Square 20.0)
let c = area (Rectangle (5.0,10.0))

Pramode C.E


Pattern Matching
type shape =

Circle of float
| Square of float
| Rectangle of (float*float)

let area s = match s with
| Circle r - 3.14 *. r *. r
| Square x - x *. x
let a = area (Circle 10.0)
let b = area (Square 20.0)
let c = area (Rectangle (5.0,10.0))

The compiler warns us when it detects that the match is not
exhaustive.
Pramode C.E


Pattern Matching

let rec len xs =
match xs with
| [] - 0
| hd :: tl - 1 + len tl
let a = len [1;2;3;4]

A simple recursive routine for computing length of a list. If list is
empty, length is 0, otherwise, it is 1 + length of remaining part of
the list.

Pramode C.E


Immutability and the nature of variables

let a = 1
let foo x = x + a;
a = 2 (* simply compares a with 2 *)
let a = 0 (* earlier binding gets shadowed *)
let m = foo 10 (* result is 11 *)

let bindings are immutable; you can shadow a binding, but an
earlier binding can't be mutated.

Pramode C.E


Immutability

Let's look at some Python list manipulation code:
a = [20, 30, 40, 50]
a.insert(0, 10)
print a # prints [10, 20, 30, 40, 50]

Python lists are mutable. The insert operation modies the original
list.

Pramode C.E


Immutability
Here is a similar program in Ocaml:
let a = [20;30;40;50]
let b = 10::a (* a remains unchanged *)
let c = [60;70;80]
let d = a @ c (* a remains unchanged *)

Good Ocaml style encourages use immutable data structures.

Pramode C.E


Immutability: Structure sharing

This is one way to implement 4::b - but it requires creating a full
copy of the old list b (red-colored cells 1, 2, 3 are copies of cells
containing the same values in b) and adding 4 at the head
position. Ocaml does NOT do it this way because it is very
inecient.

Pramode C.E



This is how Ocaml actually does 4::b. Note that the new list shares
all its elements (except 4) with the old list!

Pramode C.E



This is what happens when you append two lists A and B (using @
in Ocaml). Note that the appending operation needs to copy the
whole of list A.

Pramode C.E



The structure sharing idea can be used eciently with tree
data structures.
For more info: http:
//en.wikipedia.org/wiki/Persistent_data_structure

Persistent vectors in Scala:

http://www.codecommit.com/blog/scala/
implementing-persistent-vectors-in-scala

Pramode C.E


Mutability and aliasing

a = [1,2,3,4]
b = a
b.append(5)
print a

Having aliases to mutable objects can create very hard to track
down bugs in our code.

Pramode C.E


Non-strict evaluation

let my_if cond then_part else_part =
if cond then then_part else else_part
let a = my_if (1 2) 10 20

We are trying to write a function which behaves similar to the
built-in if control structure in Ocaml ... does it really work
properly? Let's try another example!

Pramode C.E



let foo1 () = print_string foo1n; 10
if cond then then_part else else_part
let a = my_if (1 2) (foo1()) (foo2())

Pramode C.E



The behaviour of if is non-strict: In the expression if
(cond) then e1 else e2, if cond is true e2 is NOT
EVALUATED. Also, if cond is false, e1 is NOT
EVALUATED.
By default, the behaviour of function calls in Ocaml is strict:
In the expression fun e1 e2 ... en, ALL the expressions e1, e2
... en are evaluated before the function is called.

Pramode C.E



if cond then (then_part()) else (else_part())
let a = my_if (1 2) (fun () - (foo1()))
(fun () - (foo2()))

Pramode C.E


Referential Transparency

If an expression can be replaced by its value without changing the
behaviour of the program, it is said to be referentially transparent
All occurrences of the expression 1+(2*3) can be replaced by
7 without changing the behaviour of the program.
Say the variable x (in a C program) has initial value 5. It is
NOT possible to replace all occurrences of the statement ++x
with the value 6.

Pramode C.E


Pure Functions
#include stdio.h
int balance = 1000;
int withdraw(int amt)
{
balance = balance - amt;
return balance;
}
int main()
{
printf(%dn, withdraw(100));
printf(%dn, withdraw(100));
return 0;
}
Pramode C.E


Pure Functions

A pure function always computes the same value given the
same parameters; for example, sin(0) is always 0. It is
Referentially Transparent.
Evaluation of a pure function does not cause any observable
side eects or output - like mutation of global variables or
output to I/O devices.

Pramode C.E


What is Functional Programming?

A style of programming which emphasizes composing your program
out of PURE functions and immutable data.
Theoretical foundation based on Alonzo Church's Lambda Calculus
In order for this style to be eective in the construction of real
world programs, we make use of most of the ideas seen so far
(higher order functions, lexical closures, currying, immutable and
persistent datastructures, lazy evaluation etc)

Pramode C.E


What is Functional Programming?

Questions to ask:
Is this the silver bullet?
How practical is a program composed completely out of
pure functions?
What are the benets of writing in a functional style?

Pramode C.E


Is FP the silver bullet?

Of course, there are NO silver bullets!
(http://en.wikipedia.org/wiki/No_Silver_Bullet)
Writing software is tough - no one methodology or technique
is going to solve all your problems

Pramode C.E


How practical is a program composed completely out of
pure functions?

Very impractical - unless your aim is to ght the chill by
heating up the CPU (which, by the way, is a side eect)
The idea is to write your program in such a way that it has a
purely functional core, surrounded by a few impure functions
at the outer layers

Pramode C.E


Functional core + impure outer layers
This example is simple and contrived, but it serves to illustrate the
idea. It is taken from the amazing book Functional Programming
in Scala by Paul Chiusano and Runar Bjarnason.
let declareWinner p =
let (name, score) = p in
print_string (name ^ n)
let winner p1 p2 =
let ((_, score1), (_, score2)) = (p1, p2) in
if (score1 score2) then (declareWinner p1)
else (declareWinner p2)

Note that winner is an impure function. We will now refactor it a
little!
Pramode C.E


Functional core + impure outer layers
let declareWinner p =
let (name, score) = p in
print_string (name ^ n)
let maxScore p1 p2 =
if (score1 score2) then p1 else p2
let winner p1 p2 =
declareWinner (maxScore p1 p2)

Now we have separated the computation from the display logic;
maxScore is a pure function and winner is the impure function
at the outer layer!
Pramode C.E


Benets of functional style - easy reuse, easy testing
What if we wish to nd out the winner among a set of N players?
Easy!
open Core.Std
let maxScore p1 p2 =
if (score1 score2) then p1 else p2
let a = [(Ram, 68); (John, 72); (Arun, 57)]
let b = List.reduce a maxScore

Pramode C.E


FP as good software engineering

Pure functions are easy to re-use as they have no context
other than the function parameters. (Think about re-using the
winner function in our rst version to compute the winner
among N players).
Pure functions are also easy to test. (Think about writing an
automated test for the winner function in the rst version).
Think of FP as Good Software Engineering!

Pramode C.E


Pure functions and the benet of local reasoning

If your function modies an object which is accessible from
many other functions, the eect of calling the function is much
more complex to analyse because you now have to analyse how
all these other functions get aected by the mutation.
Similarly, if the value computed by your function depends on
the value of an object which can be modied by many other
functions, it no longer becomes possible to reason about the
working of the function by only looking at the way the
function's parameters are manipulated.
The evaluation of pure functions can be done by a very simple
process of substitution.

Pramode C.E


Mutability and concurrency

Multi core CPU's are becoming commonplace
We need concurrency in our code to make eective use of the
many cores
This throws up a whole bunch of complex problems
A function can no longer assume that nobody else is watching
when it is happily mutating some data

Pramode C.E


Mutability and Concurrency

current_date = [2014, January, 7]
def changeDate(year, month, day):
current_date[0] = year
current_date[1] = month
current_date[2] = day
def showDate():
print current_date

Pramode C.E


Mutability and Concurrency
What happens if the functions changeDate() and showDate() run
as two independent threads on two CPU cores? Will showDate()
always see a consistent date value?
The traditional approach to maintaining correctness in the context
of multithreading is to use locks - but people who do it in practice
will tell you it is extremely tricky business.
It is claimed that one of the reasons for the resurgence of FP is the
emergence of multi-core processors and concurrency - it seems like
FP's emphasis on pure functions and immutability is a good match
for concurrent programming.

Pramode C.E


Moving ahead ...
Prof. Gregor Kiczales Introduction to Systematic Program
Design is a great online course for beginners:
https://www.coursera.org/course/programdesign

Join Prof.Grossman's programming languages class on
Coursera: https://www.coursera.org/course/proglang
and learn more about functional programming using SML and
Racket
Join Prof.Odersky's Functional Programming with Scala
course on Coursera for an introduction to both Scala and FP:
https://www.coursera.org/course/progfun

Watch the classic SICP lectures by Abelson and Sussman:
http://groups.csail.mit.edu/mac/classes/6.001/
abelson-sussman-lectures/

A talk by Yaron Minsky of Jane Street on how to program
eectively in ML: http://vimeo.com/14313378
Pramode C.E


Books (not limited to Ocaml)

Ocaml from the very beginning is a gentle introduction to
the language suitable for beginners:
http://ocaml-book.com/

Real world Ocaml is the book which will take you to Ocaml
mastery: http://realworldocaml.org
SICP, the classic: http://mitpress.mit.edu/sicp/
HTDP: http://www.ccs.neu.edu/home/matthias/HtDP2e/
CTM: http://www.info.ucl.ac.be/~pvr/book.html

Pramode C.E


Other resources (not limited to Ocaml)
Ocaml for the masses - ACM Queue paper by Yaron Minsky
http://queue.acm.org/detail.cfm?id=2038036

Out of the tar pit - paper by Ben Mosely and Peter Marks
(google it)
Lectures by Eric Meijer: google for C9 Lectures Erik Meijer
functional
Persistent Data Structures and Managed References - talk
by Rich Hickey (author of the Clojure programming language).
http://www.infoq.com/presentations/
Value-Identity-State-Rich-Hickey

Can programming be liberated from the von Neumann style
- by John Backus. http://www.thocp.net/biographies/
papers/backus_turingaward_lecture.pdf

Pramode C.E


Introduction to functional programming using Ocaml

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Introduction to functional programming using Ocaml

Similar to Introduction to functional programming using Ocaml (20)

Recently uploaded

Recently uploaded (20)

Introduction to functional programming using Ocaml