1. CSE-321 Programming Languages Introduction to Functional Programming
박성우
POSTECH
March 5, 2009

2. Programming Paradigms
Structured programming
C, Pascal, …
Object-oriented programming
C++, Java, …
Logic programming
Prolog, …
Functional programming
SML, Haskell, Objective Caml, Lisp, Scheme, F#, …

3. Functional Language SML
Standard ML
ML = Meta-Language
An example of programming language whose design is based on the programming language theory
type theory
Programming language for your assignments

4. Designer of SML

5. Familiar?

6. WTH?

7. Outline Expressions and values Variables Functions Types Recursion
Datatypes
Pattern matching
Higher-order functions
Exceptions
Modules

8. Imperative Language C A program consists of commands.
command = “do something”
Nothing wrong:
if (x == 1) then
x = x + 1;
else
x = x - 1;
Nothing wrong either:

9. Functional Language SML
A program consists of expressions.
expression = “obtain a value”
Nothing wrong:
if (x = 1) then
x + 1
else
x - 1
But this does not make sense:
what is the value if x <> 1?

10. Expression Evaluation An expression “evaluates” to a value.
We “evaluate” an expression to obtain a value.

11. Integer Evaluation
1 + 1 2
1 - 1
1 * 1 1 …

12. Boolean Evaluation
1 = 1
true
1 <> 1
false
1 <> 0
true …

13. An Integer Expression if 1 = ~1 then 10 else ~10
if false then else ~10
~10

14. Values as Expressions 1
???

15. Outline Expressions and values V Variables Functions Types Recursion
Datatypes
Pattern matching
Higher-order functions
Exceptions
Modules

16. Variable Declaration - val x = 1 + 1; val x = 2 : int
A variable x is “bound” to value 2.
From now on, any occurrence of x is replaced by 2.
- val y = x + x;
val y = 4 : int

17. Local Declaration let val x = 1 val y = x + x val z = y + y in z + z
end 8

18. Nested Local Declaration
let
val x = 1 in
x + x
end
let
val y = <expression> in
y + y
end
let
val y = let val x = 1 in x + x end in
y + y
end

19. Why “Local”?
let
val y = let
val x = 1 in
x + x
end
x + y
okay???

20. Variables are NOT variable.
The contents of a variable never change.
immutability of variables
Surprise?
That’s because you are thinking about variables in imperative programming.
variables in SML <> variables in C

21. Then Why Variables? Any advantage in using variables at all? let
val x = 1
val y = x + x
val z = y + y in
z + z
end
((1 + 1) + (1 + 1)) + ((1 + 1) + (1 + 1))
VS.
What if it takes 10 hours to evaluate 1?

22. Outline Expressions and values V Variables V Functions Types Recursion
Datatypes
Pattern matching
Higher-order functions
Exceptions
Modules

23. When is the first time you learned the concept of function?

24. 즐거운 낱말 공부 시간
함수(函數): 두 변수 x, y간에 어떤 관계가 있어 x의 변화에 따라 y가 일정한 법칙으로 변화할 때 y를 x의 함수라 함. (function) (동아 마스타 국어사전)

25. 函 즐거운 한자 공부 시간 1. 함(함). 2. 편지(함) 3. 갑옷(함) 4. 넣을, 들일(함) 예:
(書函) 서함: 책을 넣는 상자

26. Function = 函數 = Box Number!

27. Using a Box Number

28. Using a Box Number - Generalized… …

29. Function in SML = Box Number
(fn x => x + 1) n =

30. Function Application (fn x => x + 1) n…
(fn x => x + 1) n
We “apply” (fn x => x + 1) to n.
x is called a formal argument/parameter.
n is called an actual argument/parameter.

31. Evaluating a Function Application…
(fn x => x + 1) n
n + 1

32. Functions in SML Nameless function fn x => x + 1;
Storing a nameless function to a variable
val incr = fn x => x + 1;
Function declaration
fun incr x = x + 1;

33. Function Applications
incr 1
(fn x => x + 1) 1
1 + 1 2

34. First-class Objects First-class objects = primitive objects
can be stored in a variable.
can be passed as an argument to a function.
can be returned as a return value of a function.
Examples:
integers
booleans
characters
floating-point numbers …

35. First-class Objects in C
integers
characters
floating-point numbers
pointers
structures …
Functions?
Function pointers are first-class objects.
But functions are not.
Why? You cannot create new functions on the fly!

36. Functions = First-class Objects in SML
can be passed as an argument to a function.
can be returned as a return value of a function.

37. Box Number as Output … …
such that

38. Box Number as Output x … +x …

39. Box Number as Output x y
y+x

40. Box Number as Output x y
fn y => y+x
y+x

41. Box Number as Output x y
fn y => y+x
y+x
fn y => y+x

42. Box Number as Output x y y+x fn x => (fn y => y+x)

43. In SML Recall the following declarations are equivalent:
val incr = fn x => x + 1;
fun incr x = x + 1;
Then:
val add = fn x => (fn y => y + x);
fun add x = fn y => y + x;
fun add x y = y + x;
add takes only one argument, not two!
In fact, every function in SML takes only one argument.

44. (fn x => (fn y => y + x)) 1 2
Adding Two Integers
add 1 2
(fn x => (fn y => y + x)) 1 2
(fn y => y + 1) 2
2 + 1 3

45. Box Number as Input (
true,
false)

46. Box Number as Input f
fn f => (f true, f false) ( f
true, f
false)

47. Outline Expressions and values V Variables V Functions V Types
Recursion
Datatypes
Pattern matching
Higher-order functions
Exceptions
Modules

48. Types
A type specifies what kind of value a given expression evaluates to.
1 + 1 : int
true andalso false : bool
#”A” : char
”hello” : string
(1, true) : int * bool
(1, ~1, true) : int * int * bool
1.0 : real
() : unit

49. Type Preservation Expression : T
Value : T
An evaluation preserves the type of a given expression.

50. Example let val x = 1 val y = x + x val z = y + y in z + z end : int

51. Function Types T -> T’ type of functions:
taking arguments of type T
returning values of type T’
Example:
val incr = fn x => x + 1; val incr = fn : int -> int
fun incr x = x + 1; val incr = fn : int -> int
Explicit type annotation
val incr = fn (x:int) => x + 1;
val incr = fn (x:int) : int => x + 1;
fun incr (x:int) = x + 1;
fun incr (x:int) : int = x + 1;

52. Type of add x
fn y => y+x
fn x => (fn y => y+x)

53. Type of add
int
fn x => (fn y => y+x)
fn y => y+x

54. Type of add
int
fn x => (fn y => y+x)
int -> int

55. Type of add
int
int -> (int -> int)
int -> int

56. What is the Type? f
fn f => (f true, f false) ( f
true, f
false)

57. f : bool -> int ? ( true, false) f : (bool -> int) ->
int * int
fn f => (f true, f false) ( f
true, f
false)

58. But why is it
f : bool -> int ?

59. Why not f : bool -> char ?
char * char
fn f => (f true, f false) ( f
true, f
false)

60. f : bool -> int * string ? f : bool -> unit ?
Then why not
f : bool -> string ?
f : bool -> int * string ?
f : bool -> unit ?
f : bool -> (int -> int) ?
f : bool -> <crazy type> ? …

61. So we need
Polymorphism.

62. Announcement Assignment 1 will be out tonight.
Due at 11:59pm, March 12 (next Thursday)
Details of the instruction are all in the handout.
If you don't find your handin directory, me.
Makeup lecture
정통연 143호, 9:30am, tomorrow