CS 2104 – Prog. Lang. ConceptsFunctional Programming II

Lecturer : Dr. Abhik Roychoudhury

School of ComputingFrom Dr. Khoo Siau Cheng’s lecture notes

reduce (op *) [2,4,6] 1 ==> 2 * (4 * (6 * 1))==> 48

reduce (fn (x,y)=>1+y) [2,4,6] 0 ==> 1 + (1 + (1 + 0))==> 3

[]

:

2 :

4 :

6

+

1 +

1 +

1 0

Types: Classification of Values and

Their Operators

Type Values Operationsbool true,false =, <>, …int …,~1,0,1,2,… =,<>,<,+,div,…real ..,0.0,.,3.14,.. =,<>,<,+,/,…string “foo”,”\”q\””,… =,<>,…

Basic Types

Boolean Operations: e1 andalso e2 e1 orelse e2

Types in ML

• Every expression used in a program must be well-typed.– It is typable by the ML Type system.

• Declaring a type :3 : int

[1,2] : int list

• Usually, there is no need to declare the type in your program – ML infers it for you.

Structured TypesStructured Types consist of structured values.

• Structured values are built up through expressions. Eg : (2+3, square 3)• Structured types are denoted by type expressions.

<type-expr> ::= <type-name> | <type-constant> | <type-expr> * <type-expr>

| <type-expr> <type-expr> | <type-expr> list

| …

Type of a Tuple

A * B = set of ordered pairs (a,b)

Data Constructor : ( , ) as in (a,b)Type Constructor : * as in A * B

In general,(a1,a2,…,an) belongs to A1*A2*…*An.

(1,2) : int * int(3.14159, x+3,true) : real * int * bool

Type of A List

[1,2,3] : int list [3.14, 2.414] : real list[1, true, 3.14] : ??

Type Constructor : list

A in A-list refers to any types:(int*int) list : [ ], [(1,3)], [(3,3),(2,1)], …int list list : [ ], [[1,2]], [[1],[0,1,2],[2,3],…

A list = set of all lists of A -typed values.

Not well-typed!!

fac : int -> int

Function TypesDeclaring domain & co-

domain

Type Constructor : ->Data Construction via :1. Function declaration : fun f x = x + 1 ;2. Lambda abstraction : fn x => x + 1;

Value Selection via function application:f 3 4

(fn x => x + 1) 3 4

A -> B = set of all functions from A to B.

datatype Days = Mo | Tu | We | Th | Fr | Sa | Su ;

Selecting a summand via pattern matching:case d of Sa => “Go to cinema” | Su => “Extra Curriculum” | _ => “Life goes on”

Sum of Types Enumerated Types

New Type data / data constructors

Defining an integer binary tree:datatype IntTree = Leaf int |

Node of (IntTree, int, IntTree) ;

fun height (Leaf x) = 0 | height (Node(t1,n,t2))=

1 + max(height(t1),height(t2)) ;

Combining Sum and Product of Types:

Algebraic Data Types

Some remarks

• A functional program consists of an expression, not a sequence of statements.

• Higher-order functions are first-class citizen in the language.– It can be nameless

• List processing is convenient and expressive• In ML, every expression must be well-typed.• Algebraic data types empowers the language.

Outline

• More about Higher-order Function

• Type inference and Polymorphism

• Evaluation Strategies

• Exception Handling

Function with Multiple Arguments

• Curried functions accept multiple arguments

fun twice f x = f (f x) ;

Take 2 arguments

Apply 1st argument

Apply 2nd argument

Curried function enables partial application.

let val inc2 = twice (fn x => x + x)

in (inc2 1) + (inc2 2)

end;

val it = 12 ;

Curried vs. Uncurried

Curried functions fun twice f x = f (f x) ;

twice (fn x => x+x) 3 12

Uncurried functions fun twice’ (f, x) = f (f x) ;

twice’ (fn x => x+x, 3) 12

Curried Functions

Curried functions provide extra flexibilityto the language.

compose f g = fn x => f (g x)

compose f g x = f (g x)

compose f = fn g => fn x => f (g x)

compose = fn f => fn g => fn x => f (g x)

fun f(x,y) = x + yf : int*int -> int

Types of Multi-Argument Funs

fun g x y = x + yg : int -> int -> int

(g 3) : int -> int((g 3) 4) : int

Function application is left associative; -> is right associative

Outline

• More about Higher-order Function

• Type inference and Polymorphism

• Evaluation Strategies

• Exception Handling

Type Inference

• ML expressions seldom need type declaration.• ML cleverly infers types without much help from the user.

2 + 2 ; val it = 4 : int fun succ n = n + 1 ; val succ = fn : int -> int

• Explicit types are needed when type coercion is needed.

fun add(x,y : real) = x + y ;

fun add(x,y) = (x:real) + y;

val add = fn : real*real -> real

Helping the Type Inference

• Conditional expression has the same type at both branch.

fun abs(x) = if x>0 then x else 0-x ; val abs = fn : int -> int

Every Expression has only One Type

fun f x = if x > 0 then x else [1,2,3]val f = fn : Int -> ???

This is not type-able in ML.

Example of Type Inference

fun f g = g (g 1)

type(g) = t = intt2 = t2t3int = t2, t2 = t3

type(g) = t = int inttype(f) = t t1 = t t3

= (int int) int

tt1

tintt2

t2t3

t3

Three Type Inference Rules

(Application rule) If f x : t, then x : t’ and

f : t’ -> t for some new type t’.

(Equality rule) If both the types x : t and x : t’ can be deduced for a variable x, then t = t’.

(Function rule) If t u = t’ u’, then t = t’ and u = u’.

Example of Type Inferencefun f g = g (g 1)

Let g : tg (g (g 1)) : trhs

So, by function declaration, we havef : tg -> trhs

By application rule, let (g 1): t(g 1)

g (g 1) : trhs g : t(g 1) -> trhs.By application rule,

(g 1) : t(g 1) g : int -> t(g 1).

By equality rule : t(g 1)= int = trhs.

By equality rule : tg = int -> intHence, f : (int -> int) -> int

Parametric Polymorphism

fun I x = x ; val I = fn : ’a -> ’a

• A Polymorphic function is one whose type contains type parameters.

Type parameter

(I 3) (I [1,2]) (I square)

• Interpretation of val I = fn : ’a -> ’afor all type ‘a, function I takes an input of type ‘a and returns a result of the same type ‘a.

• A poymorphic function can be applied to arguments of more than one type.

Polymorphic Functions

• A polymorphic function is one whose type contains type parameter.

fun map f [] = []

| map f (x::xs) = (f x) :: (map f xs)

Type of map : (’a->’b) -> [’a] -> [’b]

map (fn x => x+1) [1,2,3] => [2,3,4]

map (fn x => [x]) [1,2,3] => [[1],[2],[3]]

map (fn x => x) [“y”,“n”] => [“y”, “n”]

Examples of Polymorphic Functions

fun compose f g = (fn x => f (g x))

t1t2tt4t5t4

t5t6

t4t6type(f) = t1 = t5t6type(g) = t2 = t4t5range(compose) = t = t4t6type(compose) = t1t2t

= (t5t6) (t4t5) (t4t6)

Examples of Polymorphic Functions

fun compose f g = (fn x => f (g x))

Let x:tx f:tf g:tg so compose: tf -> tg ->trhs

(fn x=>f (g x)):trhs => trhs = tx->t(f(gx))

(g x):t(gx) ==> g: tx->t(gx) and tg = tx->t(g x)

(f (g x)):t(f(gx)) ==> f:t(gx)->t(f(gx)) and tf = t(gx)->t(f(gx))

compose: (t(gx)->t(f(gx)))->(tx->t(gx))->(tx->t(f(gx)))Rename the variables:compose: (’a->’b)->(’c->’a)->(’c->’b)

Outline

• More about Higher-order Function

• Type inference and Polymorphism

• Evaluation Strategies

• Exception Handling

Approaches to Expression Evaluation

• Different approaches to evaluating an expression may change the expressiveness of a programming language.

• Two basic approaches:– Innermost (Strict) Evaluation Strategy

• SML, Scheme

– Outermost (Lazy) Evaluation Strategy• Haskell, Miranda, Lazy ML

Innermost Evaluation Strategy

• To Evaluate the call <name><actuals> : – (1) Evaluate <actuals> ;– (2) Substitute the result of (1) for the formals in

the body ;– (3) Evaluate the body of <name> ;– (4) Return the result of (3) as the answer.

let fun f x = x + 1 + x in f (2 + 3) end ;

bodyformals

actuals

fun f x = x + 2 + x ;

f (2+3) ==> f (5)==> 5 + 2 + 5==> 12

fun g x y = if (x < 3) then y else x;

g 3 (4/0) ==> g 3 ==>

• Also referred to as call-by-value evaluation.

• Occasionally, arguments are evaluated unnecessarily.

Outermost Evaluation Strategy

• To Evaluate <name><actuals> :• (1) Substitute actuals for the formals in the body ;• (2) Evaluate the body ;• (3) Return the result of (2) as the answer.

fun f x = x + 2 + x ;f (2+3) ==> (2+3) + 2 + (2+3)

==> 12fun g x y = if x < 3 then y else x ;g 3 (4/0) ==> if 3 < 3 then (4/0) else 3

==> 3

It is possible to eliminate redundant computation in outermost evaluation strategy.

fun f x = x + 2 + x ;f (2+3) ==> x + 2 + x

==> 5 + 2 + x

==> 7 + x ==> 7 + 5 ==> 12

5

x=(2+3)

Note: Arguments are evaluated only when they are needed.

Why Use Outermost Strategy?

• Closer to the meaning of mathematical functions

fun k x y = x ;val const1 = k 1 ;val const2 = k 2 ;

• Better modeling of real mathematical objectsval naturalNos = let fun inf n = n :: inf (n+1) in inf 1 end ;

Hamming Number

List, in ascending order with no repetition, all positive integers with no prime factors other than 2, 3, or 5.

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,...

n as a prime factor

fun scale n [] = []| scale n (x::xs) = (n*x) :: (scale n xs)

scale 2 [1,2,3,4,5] = [2,4,6,8,10]

scale 3 [1,2,3,4,5] = [3,6,9,12,15]

scale 3 (scale 2 [1,2,3,4,5]) = [6,12,18,24,30]

Merging two Streams

fun merge [] [] = []| merge (x::xs) (y::ys) =

if x < y then x :: merge xs (y::ys)else if x > y then y :: merge (x::xs) ys

else x :: merge xs ys

merge [2,4,6] [3,6,9] = [2,3,4,6,9]

Hamming numbers

val hamming = 1 :: merge (scale 2 hamming)

(merge (scale 3 hamming) (scale 5 hamming))

::

1

mergemerge

scale 3

scale 5

scale 2

Outline

• More about Higher-order Function

• Type inference and Polymorphism

• Evaluation Strategies

• Exception Handling

Exception Handling• Handle special cases or failure (the exceptions) occurred during program execution.

hd []; uncaught exception hd

• Exception can be raised and handled in the program. exception Nomatch;

exception Nomatch : exn

fun member(a,x) = if null(x) then raise Nomatch else if a = hd(x) then x else member(a,tl(x))

fun member(a,x) = if null(x) then raise Nomatch else if a = hd(x) then x else member(a,tl(x))

member(3,[1,2,3,1,2,3]) ; val it = [3,1,2,3] : int listmember(4,[]) ; uncaught exception Nomatchmember(5,[1,2,3]) handle Nomatch=>[]; val it = [] : int list

Conclusion

• More about Higher-order Function

– Curried vs Uncurried functions

– Full vs Partial Application

• Type inference and Polymorphism

– Basic Type inference rules

– Polymorphic functions

• Evaluation Strategies

– Innermost

– Outermost

• Exception Handling is available in ML