# INF 231 - Functional Algorithmic and Programming¶

## Lecture 2: Identifiers and functions¶

### Identifiers: Global definition¶

In [1]:
let x = 1 ;;
let y = 2 ;;
let y = x+1 ;;
y ;;

let x = 10 ;;
y ;;

let a = 2 and b = a+1 ;;

Out[1]:
val x : int = 1

Out[1]:
val y : int = 2

Out[1]:
val y : int = 2

Out[1]:
- : int = 2

Out[1]:
val x : int = 10

Out[1]:
- : int = 2

File "[1]", line 9, characters 18-19:
Error: Unbound value a
8:
9: let a = 2 and b = a+1 ;;
10: ;;


This does not work because $\texttt{a}$ is not in the context where $\texttt{b}$ is computed.

### Identifiers: Local definition¶

In [23]:
let x = 4 in x * x ;;
let a = 2 in a + 1 ;;

let term1 = 10 and term2 = 0 in term1 * term2;;

let a = 1 in let b = a+1 in let c = a+b in let d = a+b+c in d ;;

let a = 10 and b = 3 and c = 5 ;; (* we need to define three identifiers a, b and c for the next expression *)

let discriminant = b*b - 4*a*c in
if discriminant > 0 then 2
else if discriminant = 0 then 1
else 0 ;;

let e = let prod = 4*3*2 in prod*prod+prod+2 ;;

Out[23]:
- : int = 16

Out[23]:
- : int = 3

Out[23]:
- : int = 0

Out[23]:
- : int = 6

Out[23]:
val a : int = 10
val b : int = 3
val c : int = 5

Out[23]:
- : int = 0

Out[23]:
val e : int = 602


### Anonymous functions¶

In [19]:
fun x -> x ;;

Out[19]:
- : 'a -> 'a = <fun>


As you can notice the type of this function is $\texttt{'a -> 'a}$ which is $\texttt{any_type -> any_type}$ (note that the "departure type" and the "arriving" type should be the same - it can be any type. We say that this function is polymorphic -- as we shall see later in the lecture.

Below are three equivalent anonymous functions computing the absolute value.

In [20]:
fun a ->
if a < 0 then -a
else a;;

function a ->
if a < 0 then -a
else a ;;

fun (a:int) ->
if a < 0 then -a
else a ;;

Out[20]:
- : int -> int = <fun>

Out[20]:
- : int -> int = <fun>

Out[20]:
- : int -> int = <fun>


### Defining functions¶

Below are several equivalent ways to define the identy function (except that some are polymorphic). Remember that we choose to explicitely mention the parameter's types and the result type.

In [21]:
let identity = function x -> x ;;
let identity = fun x -> x ;;
let identity = function (x:int) -> x ;;
let identity = fun (x:int) -> x ;;
let identity x = x ;;
let identity (x:int):int = x ;;

Out[21]:
val identity : 'a -> 'a = <fun>

Out[21]:
val identity : 'a -> 'a = <fun>

Out[21]:
val identity : int -> int = <fun>

Out[21]:
val identity : int -> int = <fun>

Out[21]:
val identity : 'a -> 'a = <fun>

Out[21]:
val identity : int -> int = <fun>


Note that explicitely indicating the type does not forbid to be polymorphic as demonstrated by the function below.

In [24]:
let identity (x:'a):'a = x ;;

let is_zero (x:int): bool = x=0 ;;
let successor (x:int):int = x+1 ;;

let surface (length:float) (width:float):float = length *.width ;;

let pi = 3.14 in pi *. (radius**2.);;

Out[24]:
val identity : 'a -> 'a = <fun>

Out[24]:
val is_zero : int -> bool = <fun>

Out[24]:
val successor : int -> int = <fun>

Out[24]:
val surface : float -> float -> float = <fun>

Out[24]:
val surface_circle : float -> float = <fun>


### Using Functions¶

In [10]:
identity x ;;
identity (x) ;;

(fun (x:int) -> x+1) 3 ;;

surface_circle 9.76 ;;

Out[10]:
- : int = 10

Out[10]:
- : int = 10

Out[10]:
- : int = 4

Out[10]:
- : float = 299.108864


### Defining functions locally¶

In [13]:
let successor2 (x:int):int=x+1 in successor2 10 ;;

Out[13]:
- : int = 11


The command below shows that $\texttt{successor2}$ is not available globally

In [12]:
successor2 19 ;;

File "[12]", line 1, characters 0-10:
Error: Unbound value successor2
Hint: Did you mean successor?
1: successor2 19 ;;


### Defining and using functions with several parameters¶

In [14]:
let discriminant (a : int) (b : int) (c : int):int =  b * b - 4 * a * c ;;

discriminant 2 3 4 ;;

Out[14]:
val discriminant : int -> int -> int -> int = <fun>

Out[14]:
- : int = -23

In [ ]: