A Short Introduction to OCaml
|
|
|
- Leo Rogers
- 5 years ago
- Views:
Transcription
1 École Polytechnique INF549 A Short Introduction to OCaml Jean-Christophe Filliâtre September 11, 2018 Jean-Christophe Filliâtre A Short Introduction to OCaml INF549 1 / 102
2 overview lecture labs Jean-Christophe Filliâtre Stéphane Lengrand Monday 17 and Tuesday 18, 9h 12h web site for this course informatique/jean-christophe.filliatre/inf549/ questions Jean-Christophe Filliâtre A Short Introduction to OCaml INF549 2 / 102
3 OCaml OCaml is a general-purpose, strongly typed programming language successor of Caml Light (itself successor of Caml), part of the ML family (SML, F#, etc.) designed and implemented at Inria Rocquencourt by Xavier Leroy and others Some applications: symbolic computation and languages (IBM, Intel, Dassault Systèmes), static analysis (Microsoft, ENS), file synchronization (Unison), peer-to-peer (MLDonkey), finance (LexiFi, Jane Street Capital), teaching Jean-Christophe Filliâtre A Short Introduction to OCaml INF549 3 / 102
4 first steps with OCaml Jean-Christophe Filliâtre A Short Introduction to OCaml INF549 4 / 102
5 the first program hello.ml print_string "hello world!\n" compiling % ocamlopt -o hello hello.ml executing %./hello hello world! Jean-Christophe Filliâtre A Short Introduction to OCaml INF549 5 / 102
6 the first program hello.ml print_string "hello world!\n" compiling % ocamlopt -o hello hello.ml executing %./hello hello world! Jean-Christophe Filliâtre A Short Introduction to OCaml INF549 5 / 102
7 the first program hello.ml print_string "hello world!\n" compiling % ocamlopt -o hello hello.ml executing %./hello hello world! Jean-Christophe Filliâtre A Short Introduction to OCaml INF549 5 / 102
8 declarations program = sequence of declarations and expressions to evaluate let x = 1 + 2;; print_int x;; let y = x * x;; print_int y;; Jean-Christophe Filliâtre A Short Introduction to OCaml INF549 6 / 102
9 declarations program = sequence of declarations and expressions to evaluate let x = 1 + 2;; print_int x;; let y = x * x;; print_int y;; Jean-Christophe Filliâtre A Short Introduction to OCaml INF549 6 / 102
10 variable let x = e introduces a global variable differences wrt usual notion of variable: 1 necessarily initialized 2 type not declared but inferred 3 cannot be assigned Java OCaml final int x = 42; let x = 42 Jean-Christophe Filliâtre A Short Introduction to OCaml INF549 7 / 102
11 references a variable to be assigned is called a reference it is introduced with ref let x = ref 1;; print_int!x;; x :=!x + 1;; print_int!x;; Jean-Christophe Filliâtre A Short Introduction to OCaml INF549 8 / 102
12 references a variable to be assigned is called a reference it is introduced with ref let x = ref 1;; print_int!x;; x :=!x + 1;; print_int!x;; Jean-Christophe Filliâtre A Short Introduction to OCaml INF549 8 / 102
13 expressions and statements no distinction between expression/statement in the syntax : only expressions usual constructs: conditional if i = 1 then 2 else 3 for loop for i = 1 to 10 do x :=!x + i done sequence x := 1; 2 *!x Jean-Christophe Filliâtre A Short Introduction to OCaml INF549 9 / 102
14 expressions and statements no distinction between expression/statement in the syntax : only expressions usual constructs: conditional if i = 1 then 2 else 3 for loop for i = 1 to 10 do x :=!x + i done sequence x := 1; 2 *!x Jean-Christophe Filliâtre A Short Introduction to OCaml INF549 9 / 102
15 expressions and statements no distinction between expression/statement in the syntax : only expressions usual constructs: conditional if i = 1 then 2 else 3 for loop for i = 1 to 10 do x :=!x + i done sequence x := 1; 2 *!x Jean-Christophe Filliâtre A Short Introduction to OCaml INF549 9 / 102
16 expressions and statements no distinction between expression/statement in the syntax : only expressions usual constructs: conditional if i = 1 then 2 else 3 for loop for i = 1 to 10 do x :=!x + i done sequence x := 1; 2 *!x Jean-Christophe Filliâtre A Short Introduction to OCaml INF549 9 / 102
17 unit type expressions with no meaningful value (assignment, loop,...) have type unit this type has a single value, written () it is the type given to the else branch when it is omitted correct: if!x > 0 then x := 0 incorrect: 2 + (if!x > 0 then 1) Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
18 unit type expressions with no meaningful value (assignment, loop,...) have type unit this type has a single value, written () it is the type given to the else branch when it is omitted correct: if!x > 0 then x := 0 incorrect: 2 + (if!x > 0 then 1) Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
19 unit type expressions with no meaningful value (assignment, loop,...) have type unit this type has a single value, written () it is the type given to the else branch when it is omitted correct: if!x > 0 then x := 0 incorrect: 2 + (if!x > 0 then 1) Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
20 local variables in C or Java, the scope of a local variable extends to the bloc: { } int x = 1;... in OCaml, a local variable is introduced with let in: let x = 10 in x * x as for a global variable: necessarily initialized type inferred immutable but scope limited to the expression following in Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
21 local variables in C or Java, the scope of a local variable extends to the bloc: { } int x = 1;... in OCaml, a local variable is introduced with let in: let x = 10 in x * x as for a global variable: necessarily initialized type inferred immutable but scope limited to the expression following in Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
22 local variables in C or Java, the scope of a local variable extends to the bloc: { } int x = 1;... in OCaml, a local variable is introduced with let in: let x = 10 in x * x as for a global variable: necessarily initialized type inferred immutable but scope limited to the expression following in Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
23 let in = expression let x = e1 in e2 is an expression its type and value are those of e2, in an environment where x has the type and value of e1 example let x = 1 in (let y = 2 in x + y) * (let z = 3 in x * z) Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
24 let in = expression let x = e1 in e2 is an expression its type and value are those of e2, in an environment where x has the type and value of e1 example let x = 1 in (let y = 2 in x + y) * (let z = 3 in x * z) Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
25 let in = expression let x = e1 in e2 is an expression its type and value are those of e2, in an environment where x has the type and value of e1 example let x = 1 in (let y = 2 in x + y) * (let z = 3 in x * z) Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
26 parallel Java OCaml { int x = 1; let x = ref 1 in x = x + 1; x :=!x + 1; int y = x * x; let y =!x *!x in System.out.print(y); } print int y Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
27 recap program = sequence of expressions and declarations variables introduced with let and immutable no distinction expression / statement Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
28 interactive loop interactive version of the compiler % ocaml OCaml version # let x = 1 in x + 2;; - : int = 3 # let y = 1 + 2;; val y : int = 3 # y * y;; - : int = 9 Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
29 functions Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
30 syntax # let f x = x * x;; val f : int -> int = <fun> body = expression (no return) type is inferred (types of argument x and result) # f 4;; - : int = 16 Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
31 syntax # let f x = x * x;; val f : int -> int = <fun> body = expression (no return) type is inferred (types of argument x and result) # f 4;; - : int = 16 Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
32 syntax # let f x = x * x;; val f : int -> int = <fun> body = expression (no return) type is inferred (types of argument x and result) # f 4;; - : int = 16 Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
33 syntax # let f x = x * x;; val f : int -> int = <fun> body = expression (no return) type is inferred (types of argument x and result) # f 4;; - : int = 16 Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
34 parallel Java OCaml static int f(int x) { let f x = return x * x; x * x } Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
35 procedure a procedure = a function whose result type is unit example # let x = ref 1;; # let set v = x := v;; val set : int -> unit = <fun> # set 3;; - : unit = () #!x;; - : int = 3 Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
36 procedure a procedure = a function whose result type is unit example # let x = ref 1;; # let set v = x := v;; val set : int -> unit = <fun> # set 3;; - : unit = () #!x;; - : int = 3 Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
37 procedure a procedure = a function whose result type is unit example # let x = ref 1;; # let set v = x := v;; val set : int -> unit = <fun> # set 3;; - : unit = () #!x;; - : int = 3 Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
38 procedure a procedure = a function whose result type is unit example # let x = ref 1;; # let set v = x := v;; val set : int -> unit = <fun> # set 3;; - : unit = () #!x;; - : int = 3 Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
39 function without arguments takes an argument of type unit example # let reset () = x := 0;; val reset : unit -> unit = <fun> # reset ();; Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
40 function without arguments takes an argument of type unit example # let reset () = x := 0;; val reset : unit -> unit = <fun> # reset ();; Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
41 function with several arguments # let f x y z = if x > 0 then y + x else z - x;; val f : int -> int -> int -> int = <fun> # f 1 2 3;; - : int = 3 Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
42 function with several arguments # let f x y z = if x > 0 then y + x else z - x;; val f : int -> int -> int -> int = <fun> # f 1 2 3;; - : int = 3 Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
43 local function function local to an expression # let sqr x = x * x in sqr 3 + sqr 4 = sqr 5;; - : bool = true function local to another function # let pythagorean x y z = let sqr n = n * n in sqr x + sqr y = sqr z;; val pythagorean : int -> int -> int -> bool = <fun> Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
44 local function function local to an expression # let sqr x = x * x in sqr 3 + sqr 4 = sqr 5;; - : bool = true function local to another function # let pythagorean x y z = let sqr n = n * n in sqr x + sqr y = sqr z;; val pythagorean : int -> int -> int -> bool = <fun> Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
45 function as first-class citizen function = yet another expression, introduced with fun # fun x -> x+1 - : int -> int = <fun> # (fun x -> x+1) 3;; - : int = 4 internally let f x = x+1;; is identical to let f = fun x -> x+1;; Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
46 function as first-class citizen function = yet another expression, introduced with fun # fun x -> x+1 - : int -> int = <fun> # (fun x -> x+1) 3;; - : int = 4 internally let f x = x+1;; is identical to let f = fun x -> x+1;; Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
47 partial application fun x y -> x*x + y*y is the same as fun x -> fun y -> x*x + y*y one can apply a function partially example # let f x y = x*x + y*y;; val f : int -> int -> int = <fun> # let g = f 3;; val g : int -> int = <fun> # g 4;; - : int = 25 Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
48 partial application fun x y -> x*x + y*y is the same as fun x -> fun y -> x*x + y*y one can apply a function partially example # let f x y = x*x + y*y;; val f : int -> int -> int = <fun> # let g = f 3;; val g : int -> int = <fun> # g 4;; - : int = 25 Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
49 partial application a partial application is a way to return a function but one can also return a function as the result of a computation # let f x = let x2 = x * x in fun y -> x2 + y * y;; val f : int -> int -> int = <fun> a partial application of f computes x*x only once Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
50 partial application: example # let count_from n = let r = ref (n-1) in fun () -> incr r;!r;; val count_from : int -> unit -> int = <fun> # let c = count_from 0;; val c : unit -> int = <fun> # c ();; - : int = 0 # c ();; - : int = 1 Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
51 higher-order functions a function may take functions as arguments # let integral f = let n = 100 in let s = ref 0.0 in for i = 0 to n-1 do let x = float i /. float n in s :=!s +. f x done;!s /. float n # integral sin;; - : float = # integral (fun x -> x*.x);; - : float = Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
52 iteration in Java, one iterates over a collection with a cursor for (Elt x: s) {... do something with x... } in OCaml, we typically write iter (fun x ->... do something with x...) s where iter is a function provided with the data structure, with type val iter: (elt -> unit) -> set -> unit example iter (fun x -> Printf.printf "%s\n" x) s Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
53 iteration in Java, one iterates over a collection with a cursor for (Elt x: s) {... do something with x... } in OCaml, we typically write iter (fun x ->... do something with x...) s where iter is a function provided with the data structure, with type val iter: (elt -> unit) -> set -> unit example iter (fun x -> Printf.printf "%s\n" x) s Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
54 difference wrt to function pointers in C one can pass and return function pointers but OCaml functions are more than function pointers let f x = let x2 = x * x in fun y -> x2 + y * y;; the value of x2 is captured in a closure note: there are closures in Java ( 8) too s.foreach(x -> { System.out.println(x); }); Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
55 difference wrt to function pointers in C one can pass and return function pointers but OCaml functions are more than function pointers let f x = let x2 = x * x in fun y -> x2 + y * y;; the value of x2 is captured in a closure note: there are closures in Java ( 8) too s.foreach(x -> { System.out.println(x); }); Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
56 recursive functions in OCaml, it is idiomatic to use recursive functions, for a function call is cheap tail calls are optimized example: let zero f = let rec lookup i = if f i = 0 then i else lookup (i+1) in lookup 0 recursive code clearer, simpler to justify Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
57 recursive functions in OCaml, it is idiomatic to use recursive functions, for a function call is cheap tail calls are optimized example: let zero f = let rec lookup i = if f i = 0 then i else lookup (i+1) in lookup 0 recursive code clearer, simpler to justify Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
58 polymorphism # let f x = x;; val f : a -> a = <fun> # f 3;; - : int = 3 # f true;; - : bool = true # f print_int;; - : int -> unit = <fun> # f print_int 1;; 1- : unit = () Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
59 polymorphism # let f x = x;; val f : a -> a = <fun> # f 3;; - : int = 3 # f true;; - : bool = true # f print_int;; - : int -> unit = <fun> # f print_int 1;; 1- : unit = () Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
60 polymorphism OCaml always infers the most general type example: # let compose f g = fun x -> f (g x);; val compose : ( a -> b) -> ( c -> a) -> c -> b = <fun> Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
61 polymorphism OCaml always infers the most general type example: # let compose f g = fun x -> f (g x);; val compose : ( a -> b) -> ( c -> a) -> c -> b = <fun> Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
62 recap functions = first-class values: local, anonymous, arguments of other functions, etc. partially applied polymorphic function call is cheap Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
63 memory allocation Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
64 GC memory allocation handled by a garbage collector (GC) benefits: unused memory is reclaimed automatically efficient allocation forget about dynamic allocation is expensive... but keep worrying about complexity! Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
65 GC memory allocation handled by a garbage collector (GC) benefits: unused memory is reclaimed automatically efficient allocation forget about dynamic allocation is expensive... but keep worrying about complexity! Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
66 arrays # let a = Array.make 10 0;; val a : int array = [ 0; 0; 0; 0; 0; 0; 0; 0; 0; 0 ] necessarily initialized # let a = [ 1; 2; 3; 4 ];; # a.(1);; - : int = 2 # a.(1) <- 5;; - : unit = () # a;; - : int array = [ 1; 5; 3; 4 ] Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
67 arrays # let a = Array.make 10 0;; val a : int array = [ 0; 0; 0; 0; 0; 0; 0; 0; 0; 0 ] necessarily initialized # let a = [ 1; 2; 3; 4 ];; # a.(1);; - : int = 2 # a.(1) <- 5;; - : unit = () # a;; - : int array = [ 1; 5; 3; 4 ] Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
68 parallel Java OCaml int[] a = new int[42]; let a = Array.make 42 0 a[17] a.(17) a[7] = 3; a.(7) <- 3 a.length Array.length a Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
69 example: insertion sort let insertion_sort a = let swap i j = let t = a.(i) in a.(i) <- a.(j); a.(j) <- t in for i = 1 to Array.length a - 1 do (* insert element a[i] in a[0..i-1] *) let j = ref (i - 1) in while!j >= 0 && a.(!j) > a.(!j + 1) do swap!j (!j + 1); decr j done done Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
70 insertion sort let insertion_sort a = let swap i j = let t = a.(i) in a.(i) <- a.(j); a.(j) <- t in for i = 1 to Array.length a - 1 do (* insert element a[i] in a[0..i-1] *) let rec insert j = if j >= 0 && a.(j) > a.(j+1) then begin swap j (j+1); insert (j-1) end in insert (i-1) done Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
71 records like in most programming languages a record type is first declared type complex = { re : float; im : float } allocation and initialization are simultaneous: # let x = { re = 1.0; im = -1.0 };; val x : complex = {re = 1.; im = -1.} # x.im;; - : float = -1. Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
72 records like in most programming languages a record type is first declared type complex = { re : float; im : float } allocation and initialization are simultaneous: # let x = { re = 1.0; im = -1.0 };; val x : complex = {re = 1.; im = -1.} # x.im;; - : float = -1. Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
73 records like in most programming languages a record type is first declared type complex = { re : float; im : float } allocation and initialization are simultaneous: # let x = { re = 1.0; im = -1.0 };; val x : complex = {re = 1.; im = -1.} # x.im;; - : float = -1. Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
74 mutable fields type person = { name : string; mutable age : int } # let p = { name = "Martin"; age = 23 };; val p : person = {name = "Martin"; age = 23} # p.age <- p.age + 1;; - : unit = () # p.age;; - : int = 24 Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
75 mutable fields type person = { name : string; mutable age : int } # let p = { name = "Martin"; age = 23 };; val p : person = {name = "Martin"; age = 23} # p.age <- p.age + 1;; - : unit = () # p.age;; - : int = 24 Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
76 parallel Java OCaml class T { type t = { final int v; boolean b; v: int; T(int v, boolean b) { mutable b: bool; this.v = v; this.b = b; } } } T r = new T(42, true); let r = { v = 42; b = true } r.b = false; r.v r.b <- false r.v Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
77 references a reference = a record of that predefined type type a ref = { mutable contents : a } ref,! and := are syntactic sugar only arrays and mutable fields can be mutated Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
78 references a reference = a record of that predefined type type a ref = { mutable contents : a } ref,! and := are syntactic sugar only arrays and mutable fields can be mutated Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
79 references a reference = a record of that predefined type type a ref = { mutable contents : a } ref,! and := are syntactic sugar only arrays and mutable fields can be mutated Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
80 tuples usual notation # (1,2,3);; - : int * int * int = (1, 2, 3) # let v = (1, true, "hello", a );; val v : int * bool * string * char = (1, true, "hello", a ) access to components # let (a,b,c,d) = v;; val a : int = 1 val b : bool = true val c : string = "hello" val d : char = a Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
81 tuples usual notation # (1,2,3);; - : int * int * int = (1, 2, 3) # let v = (1, true, "hello", a );; val v : int * bool * string * char = (1, true, "hello", a ) access to components # let (a,b,c,d) = v;; val a : int = 1 val b : bool = true val c : string = "hello" val d : char = a Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
82 tuples useful to return several values # let rec division n m = if n < m then (0, n) else let (q,r) = division (n - m) m in (q + 1, r);; val division : int -> int -> int * int = <fun> function taking a tuple as argument # let f (x,y) = x + y;; val f : int * int -> int = <fun> # f (1,2);; - : int = 3 Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
83 tuples useful to return several values # let rec division n m = if n < m then (0, n) else let (q,r) = division (n - m) m in (q + 1, r);; val division : int -> int -> int * int = <fun> function taking a tuple as argument # let f (x,y) = x + y;; val f : int * int -> int = <fun> # f (1,2);; - : int = 3 Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
84 lists predefined type of lists, α list, immutable and homogeneous built from the empty list [] and addition in front of a list :: # let l = 1 :: 2 :: 3 :: [];; val l : int list = [1; 2; 3] shorter syntax # let l = [1; 2; 3];; Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
85 pattern matching pattern matching = case analysis on a list # let rec sum l = match l with [] -> 0 x :: r -> x + sum r;; val sum : int list -> int = <fun> # sum [1;2;3];; - : int = 6 shorter notation for a function performing pattern matching on its argument let rec sum = function [] -> 0 x :: r -> x + sum r;; Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
86 pattern matching pattern matching = case analysis on a list # let rec sum l = match l with [] -> 0 x :: r -> x + sum r;; val sum : int list -> int = <fun> # sum [1;2;3];; - : int = 6 shorter notation for a function performing pattern matching on its argument let rec sum = function [] -> 0 x :: r -> x + sum r;; Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
87 pattern matching pattern matching = case analysis on a list # let rec sum l = match l with [] -> 0 x :: r -> x + sum r;; val sum : int list -> int = <fun> # sum [1;2;3];; - : int = 6 shorter notation for a function performing pattern matching on its argument let rec sum = function [] -> 0 x :: r -> x + sum r;; Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
88 representation in memory OCaml lists = identical to lists in C or Java the list [1; 2; 3] is represented as [] Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
89 algebraic data types lists = particular case of algebraic data type algebraic data type = union of several constructors type fmla = True False And of fmla * fmla # True;; - : fmla = True # And (True, False);; - : fmla = And (True, False) lists predefined as type a list = [] :: of a * a list Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
90 algebraic data types lists = particular case of algebraic data type algebraic data type = union of several constructors type fmla = True False And of fmla * fmla # True;; - : fmla = True # And (True, False);; - : fmla = And (True, False) lists predefined as type a list = [] :: of a * a list Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
91 algebraic data types lists = particular case of algebraic data type algebraic data type = union of several constructors type fmla = True False And of fmla * fmla # True;; - : fmla = True # And (True, False);; - : fmla = And (True, False) lists predefined as type a list = [] :: of a * a list Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
92 algebraic data types lists = particular case of algebraic data type algebraic data type = union of several constructors type fmla = True False And of fmla * fmla # True;; - : fmla = True # And (True, False);; - : fmla = And (True, False) lists predefined as type a list = [] :: of a * a list Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
93 pattern matching pattern matching generalizes to algebraic data types # let rec eval = function True -> true False -> false And (f1, f2) -> eval f1 && eval f2;; val eval : fmla -> bool = <fun> Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
94 pattern matching patterns can be nested: let rec eval = function True -> true False -> false And (False, f2) -> false And (f1, False) -> false And (f1, f2) -> eval f1 && eval f2;; Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
95 pattern matching patterns can be omitted or grouped let rec eval = function True -> true False -> false And (False, _) And (_, False) -> false And (f1, f2) -> eval f1 && eval f2;; Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
96 parallel Java abstract class Fmla { } class True extends Fmla { } class False extends Fmla { } class And extends Fmla { Fmla f1, f2; } OCaml type fmla = True False And of fmla * fmla abstract class Fmla { abstract boolean eval(); } class True { boolean eval() { return true; } } class False { boolean eval() { return false; } } class And { boolean eval() { return f1.eval()&&f2.eval(); } } let rec eval = function True -> true False -> false And (f1, f2) -> eval f1 && eval f2 Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
97 pattern matching pattern matching is not limited to algebraic data types let rec mult = function [] -> 1 0 :: _ -> 0 x :: l -> x * mult l one may write let pattern = expression when there is a single pattern (as in let (a,b,c,d) = v for instance) Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
98 pattern matching pattern matching is not limited to algebraic data types let rec mult = function [] -> 1 0 :: _ -> 0 x :: l -> x * mult l one may write let pattern = expression when there is a single pattern (as in let (a,b,c,d) = v for instance) Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
99 recap allocation is cheap memory is reclaimed automatically allocated values are necessarily initialized most values cannot be mutated (only arrays and mutable record fields can be) efficient representation of values pattern matching = case analysis over values Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
100 execution model Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
101 values a value is either a primitive value (integer, floating point, Boolean, [], etc.) or a pointer (to an array, a constructor such as And, etc.) it fits on 64 bits passing mode is by value in particular, no value is ever copied it is exactly as in Java Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
102 no null value in OCaml, there is no such thing as null in particular, any value is necessarily initialized sometimes a pain, but it s worth the effort: an expression of type τ whose evaluation terminates necessarily has a legal value of type τ this is known as strong typing no such thing as NullPointerException (neither segmentation fault as in C/C++) Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
103 comparison equality written == is physical equality, that is, equality of pointers or primitive values # (1, 2) == (1, 2);; - : bool = false as in Java equality written =, on the contrary, is structural equality, that is, recursive equality descending in sub-terms # (1, 2) = (1, 2);; - : bool = true it is equivalent to equals in Java (when suitably defined) Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
104 exceptions Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
105 exceptions usual notion an exception may be raised let division n m = if m = 0 then raise Division_by_zero else... and later caught try division x y with Division_by_zero -> (0,0) one can introduce new exceptions exception Error exception Unix_error of string Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
106 exceptions usual notion an exception may be raised let division n m = if m = 0 then raise Division_by_zero else... and later caught try division x y with Division_by_zero -> (0,0) one can introduce new exceptions exception Error exception Unix_error of string Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
107 exceptions usual notion an exception may be raised let division n m = if m = 0 then raise Division_by_zero else... and later caught try division x y with Division_by_zero -> (0,0) one can introduce new exceptions exception Error exception Unix_error of string Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
108 idiom in OCaml, exceptions are used in the library to signal exceptional behavior example: Not found to signal a missing value try let v = Hashtbl.find table key in... with Not_found ->... (where Java typically returns null) Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
109 modules and functors Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
110 software engineering when programs get big we need to split code into units (modularity) hide data representation (encapsulation) avoid duplicating code in OCaml, this is provided by modules Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
111 files and modules each file is a module if arith.ml contains let pi = let round x = floor (x ) we compile it with % ocamlopt -c arith.ml we use it within another module main.ml: let x = float_of_string (read_line ());; print_float (Arith.round (x /. Arith.pi));; print_newline ();; % ocamlopt -c main.ml % ocamlopt arith.cmx main.cmx Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
112 files and modules each file is a module if arith.ml contains let pi = let round x = floor (x ) we compile it with % ocamlopt -c arith.ml we use it within another module main.ml: let x = float_of_string (read_line ());; print_float (Arith.round (x /. Arith.pi));; print_newline ();; % ocamlopt -c main.ml % ocamlopt arith.cmx main.cmx Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
113 files and modules each file is a module if arith.ml contains let pi = let round x = floor (x ) we compile it with % ocamlopt -c arith.ml we use it within another module main.ml: let x = float_of_string (read_line ());; print_float (Arith.round (x /. Arith.pi));; print_newline ();; % ocamlopt -c main.ml % ocamlopt arith.cmx main.cmx Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
114 files and modules each file is a module if arith.ml contains let pi = let round x = floor (x ) we compile it with % ocamlopt -c arith.ml we use it within another module main.ml: let x = float_of_string (read_line ());; print_float (Arith.round (x /. Arith.pi));; print_newline ();; % ocamlopt -c main.ml % ocamlopt arith.cmx main.cmx Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
115 files and modules each file is a module if arith.ml contains let pi = let round x = floor (x ) we compile it with % ocamlopt -c arith.ml we use it within another module main.ml: let x = float_of_string (read_line ());; print_float (Arith.round (x /. Arith.pi));; print_newline ();; % ocamlopt -c main.ml % ocamlopt arith.cmx main.cmx Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
116 encapsulation we can limit what is exported with an interface in a file arith.mli val round : float -> float % ocamlopt -c arith.mli % ocamlopt -c arith.ml % ocamlopt -c main.ml File "main.ml", line 2, characters 33-41: Unbound value Arith.pi Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
117 encapsulation we can limit what is exported with an interface in a file arith.mli val round : float -> float % ocamlopt -c arith.mli % ocamlopt -c arith.ml % ocamlopt -c main.ml File "main.ml", line 2, characters 33-41: Unbound value Arith.pi Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
118 encapsulation we can limit what is exported with an interface in a file arith.mli val round : float -> float % ocamlopt -c arith.mli % ocamlopt -c arith.ml % ocamlopt -c main.ml File "main.ml", line 2, characters 33-41: Unbound value Arith.pi Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
119 encapsulation we can limit what is exported with an interface in a file arith.mli val round : float -> float % ocamlopt -c arith.mli % ocamlopt -c arith.ml % ocamlopt -c main.ml File "main.ml", line 2, characters 33-41: Unbound value Arith.pi Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
120 encapsulation an interface may also hide the definition of a type in set.ml type t = int list let empty = [] let add x l = x :: l let mem = List.mem but in set.mli type t val empty : t val add : int -> t -> t val mem : int -> t -> bool type t is an abstract type Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
121 encapsulation an interface may also hide the definition of a type in set.ml type t = int list let empty = [] let add x l = x :: l let mem = List.mem but in set.mli type t val empty : t val add : int -> t -> t val mem : int -> t -> bool type t is an abstract type Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
122 encapsulation an interface may also hide the definition of a type in set.ml type t = int list let empty = [] let add x l = x :: l let mem = List.mem but in set.mli type t val empty : t val add : int -> t -> t val mem : int -> t -> bool type t is an abstract type Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
123 encapsulation an interface may also hide the definition of a type in set.ml type t = int list let empty = [] let add x l = x :: l let mem = List.mem but in set.mli type t val empty : t val add : int -> t -> t val mem : int -> t -> bool type t is an abstract type Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
124 separate compilation the compilation of a file only depends on the interfaces of the other files fewer recompilation when a code changes but its interface does not Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
125 separate compilation the compilation of a file only depends on the interfaces of the other files fewer recompilation when a code changes but its interface does not Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
126 module system not limited to files module M = struct let c = 100 let f x = c * x end module A = struct let a = 2 module B = struct let b = 3 let f x = a * b * x end let f x = B.f (x + 1) end Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
127 module system not limited to files module M = struct let c = 100 let f x = c * x end module A = struct let a = 2 module B = struct let b = 3 let f x = a * b * x end let f x = B.f (x + 1) end Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
128 module system not limited to files module M = struct let c = 100 let f x = c * x end module A = struct let a = 2 module B = struct let b = 3 let f x = a * b * x end let f x = B.f (x + 1) end Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
129 module system similar for interfaces module type S = sig val f : int -> int end interface constraint module M : S = struct let a = 2 let f x = a * x end # M.a;; Unbound value M.a Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
130 module system similar for interfaces module type S = sig val f : int -> int end interface constraint module M : S = struct let a = 2 let f x = a * x end # M.a;; Unbound value M.a Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
131 module system similar for interfaces module type S = sig val f : int -> int end interface constraint module M : S = struct let a = 2 let f x = a * x end # M.a;; Unbound value M.a Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
132 module system similar for interfaces module type S = sig val f : int -> int end interface constraint module M : S = struct let a = 2 let f x = a * x end # M.a;; Unbound value M.a Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
133 recap code split into units called modules encapsulation of types and values, abstract types separate compilation organizes the name space Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
134 functors functor = module parameterized with other modules example: hash table one has to parameterize wrt hash function and equality function Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
135 functors functor = module parameterized with other modules example: hash table one has to parameterize wrt hash function and equality function Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
136 the solution: a functor module type HashedType = sig type elt val hash: elt -> int val eq : elt -> elt -> bool end module HashTable(X: HashedType) = struct... end Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
137 functor definition module HashTable(X: HashedType) = struct type t = X.elt list array let create n = Array.make n [] let add t x = let i = (X.hash x) mod (Array.length t) in t.(i) <- x :: t.(i) let mem t x = let i = (X.hash x) mod (Array.length t) in List.exists (X.eq x) t.(i) end inside, X is used as any regular module Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
138 functor type module HashTable(X: HashedType) : sig type t val create : int -> t val add : t -> X.elt -> unit val mem : t -> X.elt -> bool end Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
139 functor use module Int = struct type elt = int let hash x = abs x let eq x y = x=y end module Hint = HashTable(Int) # let t = Hint.create 17;; val t : Hint.t = <abstr> # Hint.add t 13;; - : unit = () # Hint.add t 173;; - : unit = () Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
140 functor use module Int = struct type elt = int let hash x = abs x let eq x y = x=y end module Hint = HashTable(Int) # let t = Hint.create 17;; val t : Hint.t = <abstr> # Hint.add t 13;; - : unit = () # Hint.add t 173;; - : unit = () Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
141 functor use module Int = struct type elt = int let hash x = abs x let eq x y = x=y end module Hint = HashTable(Int) # let t = Hint.create 17;; val t : Hint.t = <abstr> # Hint.add t 13;; - : unit = () # Hint.add t 173;; - : unit = () Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
142 parallel Java OCaml interface HashedType<T> { module type HashedType = sig type elt int hash(); val hash: elt -> int boolean eq(t x); val eq: elt -> elt -> bool } end class HashTable module HashTable(E: HashedType) = <E extends HashedType<E>> { struct Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
143 applications of functors 1 data structures parameterized with other data structures Hashtbl.Make : hash tables Set.Make : finite sets implemented with balanced trees Map.Make : finite maps implemented with balanced trees 2 algorithms parameterized with data structures Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
144 example: Dijkstra s algorithm module Dijkstra (G: sig type graph type vertex val succ: graph -> vertex -> (vertex * float) list end) : sig val shortest_path: G.graph -> G.vertex -> G.vertex -> G.vertex list * float end Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
145 persistence Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
146 immutable data structures in OCaml, most data structures are immutable (exceptions are arrays and records with mutable fields) said otherwise: a value is not modified by an operation, but a new value is returned terminology: this is called applicative programming or functional programming Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
147 example of immutable structure: lists let l = [1; 2; 3] let l = 0 :: l l l [] no copy, but sharing Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
148 counterpart adding an element at the end of the list is not simple: l [] Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
149 concatenating two lists let rec append l1 l2 = match l1 with [] -> l2 x :: l -> x :: append l l2 let l = [1; 2; 3] let l = [4; 5] let l = append l l l l [] l 4 5 [] blocs of l are copied, blocs of l are shared Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
150 concatenating two lists let rec append l1 l2 = match l1 with [] -> l2 x :: l -> x :: append l l2 let l = [1; 2; 3] let l = [4; 5] let l = append l l l l [] l 4 5 [] blocs of l are copied, blocs of l are shared Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
151 concatenating two lists let rec append l1 l2 = match l1 with [] -> l2 x :: l -> x :: append l l2 let l = [1; 2; 3] let l = [4; 5] let l = append l l l l [] l 4 5 [] blocs of l are copied, blocs of l are shared Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
152 mutable linked lists note: one can implement traditional linked lists, for instance with type a mlist = Empty Element of a element and a element = { value: a; mutable next: a mlist } but then be careful with sharing (aliasing) Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
153 another example: trees type tree = Empty Node of int * tree * tree val add : int -> tree -> tree again, few copies and mostly sharing Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
154 benefits of persistence 1 correctness of programs code is simpler mathematical reasoning is possible 2 easy to perform backtracking search algorithms symbolic manipulation and scopes error recovery Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
155 benefits of persistence 1 correctness of programs code is simpler mathematical reasoning is possible 2 easy to perform backtracking search algorithms symbolic manipulation and scopes error recovery Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
156 persistence and backtracking (1) search for a path in a maze type state val is_exit : state -> bool type move val moves : state -> move list val move : state -> move -> state let rec search e = is_exit e iter e (moves e) and iter e = function [] -> false d :: r -> search (move d e) iter e r Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
157 persistence and backtracking (1) search for a path in a maze type state val is_exit : state -> bool type move val moves : state -> move list val move : state -> move -> state let rec search e = is_exit e iter e (moves e) and iter e = function [] -> false d :: r -> search (move d e) iter e r Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
158 persistence and backtracking (1) search for a path in a maze type state val is_exit : state -> bool type move val moves : state -> move list val move : state -> move -> state let rec search e = is_exit e iter e (moves e) and iter e = function [] -> false d :: r -> search (move d e) iter e r Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
159 without persistence with a mutable, global state let rec search () = is_exit () iter (moves ()) and iter = function [] -> false d :: r -> (move d; search ()) (undo d; iter r) i.e. one has to undo the side effect (here with a function undo, inverse of move) Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
160 persistence and backtracking (2) simple Java fragments, represented with type stmt = Return of string Var of string * int If of string * string * stmt list * stmt list example: int x = 1; int z = 2; if (x == z) { int y = 2; if (y == z) return y; else return z; } else return x; Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
161 persistence and backtracking (2) let us check that any variable which is used was previously declared (within a list of statements) val check_stmt : string list -> stmt -> bool val check_prog : string list -> stmt list -> bool Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
162 persistence and backtracking (2) let rec check_instr vars = function Return x -> List.mem x vars If (x, y, p1, p2) -> List.mem x vars && List.mem y vars && check_prog vars p1 && check_prog vars p2 Var _ -> true and check_prog vars = function [] -> true Var (x, _) :: p -> check_prog (x :: vars) p i :: p -> check_instr vars i && check_prog vars p Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
163 persistence and backtracking (2) let rec check_instr vars = function Return x -> List.mem x vars If (x, y, p1, p2) -> List.mem x vars && List.mem y vars && check_prog vars p1 && check_prog vars p2 Var _ -> true and check_prog vars = function [] -> true Var (x, _) :: p -> check_prog (x :: vars) p i :: p -> check_instr vars i && check_prog vars p Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
164 persistence and backtracking (3) a program handles a database non atomic updates, requiring lot of computation with a mutable state try... performs update on the database... with e ->... rollback database to a consistent state handle the error... Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
165 persistence and backtracking (3) a program handles a database non atomic updates, requiring lot of computation with a mutable state try... performs update on the database... with e ->... rollback database to a consistent state handle the error... Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
166 persistence and backtracking (3) a program handles a database non atomic updates, requiring lot of computation with a mutable state try... performs update on the database... with e ->... rollback database to a consistent state handle the error... Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
167 persistence and backtracking (3) with a persistent data structure let bd = ref (... initial database...)... try bd := (... compute the update of!bd...) with e ->... handle the error... Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
168 interface and persistence the persistent nature of a type is not obvious the signature provides implicit information mutable data structure type t val create : unit -> t val add : int -> t -> unit val remove : int -> t -> unit... persistent data structure type t val empty : t val add : int -> t -> t val remove : int -> t -> t... Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
169 interface and persistence the persistent nature of a type is not obvious the signature provides implicit information mutable data structure type t val create : unit -> t val add : int -> t -> unit val remove : int -> t -> unit... persistent data structure type t val empty : t val add : int -> t -> t val remove : int -> t -> t... Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
170 interface and persistence the persistent nature of a type is not obvious the signature provides implicit information mutable data structure type t val create : unit -> t val add : int -> t -> unit val remove : int -> t -> unit... persistent data structure type t val empty : t val add : int -> t -> t val remove : int -> t -> t... Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
171 interface and persistence the persistent nature of a type is not obvious the signature provides implicit information mutable data structure type t val create : unit -> t val add : int -> t -> unit val remove : int -> t -> unit... persistent data structure type t val empty : t val add : int -> t -> t val remove : int -> t -> t... Jean-Christophe Filliâtre A Short Introduction to OCaml INF / 102
CSCI-GA Scripting Languages
CSCI-GA.3033.003 Scripting Languages 12/02/2013 OCaml 1 Acknowledgement The material on these slides is based on notes provided by Dexter Kozen. 2 About OCaml A functional programming language All computation
CMSC 330: Organization of Programming Languages. Functional Programming with Lists
CMSC 330: Organization of Programming Languages Functional Programming with Lists 1 Lists in OCaml The basic data structure in OCaml Lists can be of arbitrary length Implemented as a linked data structure
CMSC 330: Organization of Programming Languages. Functional Programming with Lists
CMSC 330: Organization of Programming Languages Functional Programming with Lists CMSC330 Spring 2018 1 Lists in OCaml The basic data structure in OCaml Lists can be of arbitrary length Implemented as
CS Lectures 2-3. Introduction to OCaml. Polyvios Pratikakis
CS 490.40 Lectures 2-3 Introduction to OCaml Polyvios Pratikakis Based on slides by Jeff Foster History ML: Meta Language 1973, University of Edinburg Used to program search tactics in LCF theorem prover
Mutation. COS 326 David Walker Princeton University
Mutation COS 326 David Walker Princeton University Mutation? 2 Thus far We have considered the (almost) purely functional subset of Ocaml. We ve had a few side effects: printing & raising exceptions. Two
Dialects of ML. CMSC 330: Organization of Programming Languages. Dialects of ML (cont.) Features of ML. Functional Languages. Features of ML (cont.
CMSC 330: Organization of Programming Languages OCaml 1 Functional Programming Dialects of ML ML (Meta Language) Univ. of Edinburgh,1973 Part of a theorem proving system LCF The Logic of Computable Functions
Why OCaml? Introduction to Objective Caml. Features of OCaml. Applications written in OCaml. Stefan Wehr
Motivation Introduction to Objective Caml Why OCaml? Stefan Wehr University of Freiburg. October 30, 2006 Motivation Simple Expressions and Types I/O and Compilation Resources Convenient encoding of tree
Introduction to Objective Caml
Introduction to Objective Caml Stefan Wehr University of Freiburg. October 30, 2006 Motivation Simple Expressions and Types Functions Simple Pattern Matching Compound Datatypes I/O and Compilation Resources
Some Advanced ML Features
Some Advanced ML Features Mooly Sagiv Michael Clarkson, Cornell CS 3110 Data Structures and Functional Programming University of Washington: Dan Grossman ML is small Small number of powerful constructs
COSE212: Programming Languages. Lecture 3 Functional Programming in OCaml
COSE212: Programming Languages Lecture 3 Functional Programming in OCaml Hakjoo Oh 2017 Fall Hakjoo Oh COSE212 2017 Fall, Lecture 3 September 18, 2017 1 / 44 Why learn ML? Learning ML is a good way of
OCaml Data CMSC 330: Organization of Programming Languages. User Defined Types. Variation: Shapes in Java
OCaml Data : Organization of Programming Languages OCaml 4 Data Types & Modules So far, we ve seen the following kinds of data Basic types (int, float, char, string) Lists Ø One kind of data structure
22c:111 Programming Language Concepts. Fall Types I
22c:111 Programming Language Concepts Fall 2008 Types I Copyright 2007-08, The McGraw-Hill Company and Cesare Tinelli. These notes were originally developed by Allen Tucker, Robert Noonan and modified
Background. CMSC 330: Organization of Programming Languages. Useful Information on OCaml language. Dialects of ML. ML (Meta Language) Standard ML
CMSC 330: Organization of Programming Languages Functional Programming with OCaml 1 Background ML (Meta Language) Univ. of Edinburgh, 1973 Part of a theorem proving system LCF The Logic of Computable Functions
Chapter 11 :: Functional Languages
Chapter 11 :: Functional Languages Programming Language Pragmatics Michael L. Scott Copyright 2016 Elsevier 1 Chapter11_Functional_Languages_4e - Tue November 21, 2017 Historical Origins The imperative
Tuples. CMSC 330: Organization of Programming Languages. Examples With Tuples. Another Example
CMSC 330: Organization of Programming Languages OCaml 2 Higher Order Functions Tuples Constructed using (e1,..., en) Deconstructed using pattern matching Patterns involve parens and commas, e.g., (p1,p2,
CSE 341 Section 5. Winter 2018
CSE 341 Section 5 Winter 2018 Midterm Review! Variable Bindings, Shadowing, Let Expressions Boolean, Comparison and Arithmetic Operations Equality Types Types, Datatypes, Type synonyms Tuples, Records
CMSC 330: Organization of Programming Languages. OCaml Imperative Programming
CMSC 330: Organization of Programming Languages OCaml Imperative Programming CMSC330 Fall 2017 1 So Far, Only Functional Programming We haven t given you any way so far to change something in memory All
Begin at the beginning
Begin at the beginning Expressions (Syntax) Exec-time Dynamic Values (Semantics) Compile-time Static Types 1. Programmer enters expression 2. ML checks if expression is well-typed Using a precise set of
CS152: Programming Languages. Lecture 11 STLC Extensions and Related Topics. Dan Grossman Spring 2011
CS152: Programming Languages Lecture 11 STLC Extensions and Related Topics Dan Grossman Spring 2011 Review e ::= λx. e x e e c v ::= λx. e c τ ::= int τ τ Γ ::= Γ, x : τ (λx. e) v e[v/x] e 1 e 1 e 1 e
CMSC 330: Organization of Programming Languages. OCaml Imperative Programming
CMSC 330: Organization of Programming Languages OCaml Imperative Programming CMSC330 Spring 2018 1 So Far, Only Functional Programming We haven t given you any way so far to change something in memory
CS 11 Haskell track: lecture 1
CS 11 Haskell track: lecture 1 This week: Introduction/motivation/pep talk Basics of Haskell Prerequisite Knowledge of basic functional programming e.g. Scheme, Ocaml, Erlang CS 1, CS 4 "permission of
CSCI 2041: Basic OCaml Syntax and Features
CSCI 2041: Basic OCaml Syntax and Features Chris Kauffman Last Updated: Wed Sep 12 14:37:38 CDT 2018 1 Logistics OCaml System Manual: 1.1-1.3 Practical OCaml: Ch 1-2 OCaml System Manual: 25.2 (Pervasives
Recap: Functions as first-class values
Recap: Functions as first-class values Arguments, return values, bindings What are the benefits? Parameterized, similar functions (e.g. Testers) Creating, (Returning) Functions Iterator, Accumul, Reuse
A Func'onal Introduc'on. COS 326 David Walker Princeton University
A Func'onal Introduc'on COS 326 David Walker Princeton University Thinking Func'onally In Java or C, you get (most) work done by changing something temp = pair.x; pair.x = pair.y; pair.y = temp; commands
Mutation. COS 326 Andrew W. Appel Princeton University. slides copyright David Walker and Andrew W. Appel
Mutation COS 326 Andrew W. Appel Princeton University slides copyright 2013-2015 David Walker and Andrew W. Appel Mutation? 2 Reasoning about Mutable State is Hard mutable set insert i s1; f x; member
A brief introduction to C programming for Java programmers
A brief introduction to C programming for Java programmers Sven Gestegård Robertz September 2017 There are many similarities between Java and C. The syntax in Java is basically
COP4020 Programming Languages. Functional Programming Prof. Robert van Engelen
COP4020 Programming Languages Functional Programming Prof. Robert van Engelen Overview What is functional programming? Historical origins of functional programming Functional programming today Concepts
D7020E. The dynamic evolution of a system Robust and Energy-Efficient Real-Time Systems. blocked Lecture 2: Components & the Timber language.
Recall The dynamic evolution of a system Robust and Energy-Efficient Real-Time Systems with offset asynchronous calls synchronous call T T blocked Lecture 2: Components & the Timber language buffered??
D7020E. Robust and Energy-Efficient Real-Time Systems D7020E. Lecture 2: Components & the Timber language
Robust and Energy-Efficient Real-Time Systems Lecture 2: Components & the Timber language 1 1 Recall The dynamic evolution of a system... with offset asynchronous calls synchronous call T T blocked buffered
Introduction to OCaml
Fall 2018 Introduction to OCaml Yu Zhang Course web site: http://staff.ustc.edu.cn/~yuzhang/tpl References Learn X in Y Minutes Ocaml Real World OCaml Cornell CS 3110 Spring 2018 Data Structures and Functional
Lists. Michael P. Fourman. February 2, 2010
Lists Michael P. Fourman February 2, 2010 1 Introduction The list is a fundamental datatype in most functional languages. ML is no exception; list is a built-in ML type constructor. However, to introduce
Programming Languages and Techniques (CIS120)
Programming Languages and Techniques (CIS120) Lecture 10 February 5 th, 2016 Abstract types: sets Lecture notes: Chapter 10 What is the value of this expresssion? let f (x:bool) (y:int) : int = if x then
Functional Languages. CSE 307 Principles of Programming Languages Stony Brook University
Functional Languages CSE 307 Principles of Programming Languages Stony Brook University http://www.cs.stonybrook.edu/~cse307 1 Historical Origins 2 The imperative and functional models grew out of work
CS321 Languages and Compiler Design I Winter 2012 Lecture 13
STATIC SEMANTICS Static Semantics are those aspects of a program s meaning that can be studied at at compile time (i.e., without running the program). Contrasts with Dynamic Semantics, which describe how
Side note: Tail Recursion. Begin at the beginning. Side note: Tail Recursion. Base Types. Base Type: int. Base Type: int
Begin at the beginning Epressions (Synta) Compile-time Static Eec-time Dynamic Types Values (Semantics) 1. Programmer enters epression 2. ML checks if epression is well-typed Using a precise set of rules,
Tail Recursion: Factorial. Begin at the beginning. How does it execute? Tail recursion. Tail recursive factorial. Tail recursive factorial
Begin at the beginning Epressions (Synta) Compile-time Static Eec-time Dynamic Types Values (Semantics) 1. Programmer enters epression 2. ML checks if epression is well-typed Using a precise set of rules,
CMSC 330: Organization of Programming Languages. Lets, Tuples, Records
CMSC 330: Organization of Programming Languages Lets, Tuples, Records CMSC330 Spring 2018 1 Let Expressions Enable binding variables in other expressions These are different from the let definitions we
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages CMSC330 Fall 2017 OCaml Data Types CMSC330 Fall 2017 1 OCaml Data So far, we ve seen the following kinds of data Basic types (int, float, char, string) Lists
CS 11 Ocaml track: lecture 4. Today: modules
CS 11 Ocaml track: lecture 4 Today: modules The idea of modules What's the idea behind a "module"? Package up code so other people/programs can use it Control what parts of code are part of the interface
CSCI 2041: Functions, Mutation, and Arrays
CSCI 2041: Functions, Mutation, and Arrays Chris Kauffman Last Updated: Fri Sep 14 15:06:04 CDT 2018 1 Logistics OCaml System Manual: 1.1-1.3 Practical OCaml: Ch 1-2 OCaml System Manual: 25.2 (Pervasives
CSE341: Programming Languages Lecture 9 Function-Closure Idioms. Dan Grossman Fall 2011
CSE341: Programming Languages Lecture 9 Function-Closure Idioms Dan Grossman Fall 2011 More idioms We know the rule for lexical scope and function closures Now what is it good for A partial but wide-ranging
Typed Racket: Racket with Static Types
Typed Racket: Racket with Static Types Version 5.0.2 Sam Tobin-Hochstadt November 6, 2010 Typed Racket is a family of languages, each of which enforce that programs written in the language obey a type
CSE341: Programming Languages Lecture 9 Function-Closure Idioms. Dan Grossman Winter 2013
CSE341: Programming Languages Lecture 9 Function-Closure Idioms Dan Grossman Winter 2013 More idioms We know the rule for lexical scope and function closures Now what is it good for A partial but wide-ranging
Metaprogramming assignment 3
Metaprogramming assignment 3 Optimising embedded languages Due at noon on Thursday 29th November 2018 This exercise uses the BER MetaOCaml compiler, which you can install via opam. The end of this document
Programming Languages and Techniques (CIS120)
Programming Languages and Techniques () Lecture 20 February 28, 2018 Transition to Java Announcements HW05: GUI programming Due: THURSDAY!! at 11:59:59pm Lots of TA office hours today Thursday See Piazza
Review. CS152: Programming Languages. Lecture 11 STLC Extensions and Related Topics. Let bindings (CBV) Adding Stuff. Booleans and Conditionals
Review CS152: Programming Languages Lecture 11 STLC Extensions and Related Topics e ::= λx. e x ee c v ::= λx. e c (λx. e) v e[v/x] e 1 e 2 e 1 e 2 τ ::= int τ τ Γ ::= Γ,x : τ e 2 e 2 ve 2 ve 2 e[e /x]:
An introduction introduction to functional functional programming programming using usin Haskell
An introduction to functional programming using Haskell Anders Møller amoeller@cs.au.dkau Haskell The most popular p purely functional, lazy programming g language Functional programming language : a program
Cunning Plan. One-Slide Summary. Functional Programming. Functional Programming. Introduction to COOL #1. Classroom Object-Oriented Language
Functional Programming Introduction to COOL #1 Cunning Plan Functional Programming Types Pattern Matching Higher-Order Functions Classroom Object-Oriented Language Methods Attributes Inheritance Method
All the operations used in the expression are over integers. a takes a pair as argument. (a pair is also a tuple, or more specifically, a 2-tuple)
Weekly exercises in INF3110 week 41 6-10.10.2008 Exercise 1 Exercise 6.1 in Mitchell's book a) fun a(x,y) = x+2*y; val a = fn : int * int -> int All the operations used in the expression are over integers.
SML A F unctional Functional Language Language Lecture 19
SML A Functional Language Lecture 19 Introduction to SML SML is a functional programming language and acronym for Standard d Meta Language. SML has basic data objects as expressions, functions and list
Haske k ll An introduction to Functional functional programming using Haskell Purely Lazy Example: QuickSort in Java Example: QuickSort in Haskell
Haskell An introduction to functional programming using Haskell Anders Møller amoeller@cs.au.dk The most popular purely functional, lazy programming language Functional programming language : a program
CVO103: Programming Languages. Lecture 5 Design and Implementation of PLs (1) Expressions
CVO103: Programming Languages Lecture 5 Design and Implementation of PLs (1) Expressions Hakjoo Oh 2018 Spring Hakjoo Oh CVO103 2018 Spring, Lecture 5 April 3, 2018 1 / 23 Plan Part 1 (Preliminaries):
The Typed Racket Guide
The Typed Racket Guide Version 5.3.6 Sam Tobin-Hochstadt and Vincent St-Amour August 9, 2013 Typed Racket is a family of languages, each of which enforce
OCaml. ML Flow. Complex types: Lists. Complex types: Lists. The PL for the discerning hacker. All elements must have same type.
OCaml The PL for the discerning hacker. ML Flow Expressions (Syntax) Compile-time Static 1. Enter expression 2. ML infers a type Exec-time Dynamic Types 3. ML crunches expression down to a value 4. Value
L3 Programming September 19, OCaml Cheatsheet
OCaml Cheatsheet Note: this document comes from a previous course (by Sylvain Schimdt). The explanations of the OCaml syntax in this sheet are by no means intended to be complete or even sufficient; check
A First Look at ML. Chapter Five Modern Programming Languages, 2nd ed. 1
A First Look at ML Chapter Five Modern Programming Languages, 2nd ed. 1 ML Meta Language One of the more popular functional languages (which, admittedly, isn t saying much) Edinburgh, 1974, Robin Milner
Plan (next 4 weeks) 1. Fast forward. 2. Rewind. 3. Slow motion. Rapid introduction to what s in OCaml. Go over the pieces individually
Plan (next 4 weeks) 1. Fast forward Rapid introduction to what s in OCaml 2. Rewind 3. Slow motion Go over the pieces individually History, Variants Meta Language Designed by Robin Milner @ Edinburgh Language
News. CSE 130: Programming Languages. Environments & Closures. Functions are first-class values. Recap: Functions as first-class values
CSE 130: Programming Languages Environments & Closures News PA 3 due THIS Friday (5/1) Midterm NEXT Friday (5/8) Ranjit Jhala UC San Diego Recap: Functions as first-class values Arguments, return values,
CSE 130 [Winter 2014] Programming Languages
![CSE 130 [Winter 2014] Programming Languages](/thumbs/85/92581372.jpg "CSE 130 [Winter 2014] Programming Languages")
CSE 130 [Winter 2014] Programming Languages Introduction to OCaml (Continued) Ravi Chugh! Jan 14 Announcements HW #1 due Mon Jan 20 Post questions/discussion to Piazza Check Piazza for TA/Tutor lab hours
CS3110 Spring 2016 Lecture 6: Modules
CS3110 Spring 2016 Lecture 6: Modules Modules are the O part of OCaml, influenced by objects in Java. We see the evolution: Classic ML, CambridgeML (CAML), and finally OCaml. David McQueen is writing the
Functional Programming. Introduction To Cool
Functional Programming Introduction To Cool #1 Cunning Plan ML Functional Programming Fold Sorting Cool Overview Syntax Objects Methods Types #2 This is my final day... as your... companion... through
Programming Languages
CSE 130 : Fall 2008 Programming Languages Lecture 3: Epressions and Types Ranjit Jhala UC San Diego News PA 1 due (net) Fri 10/10 5pm PA 2 out today or tomorrow Office hours posted on Webpage: Held in
Part I. Language Core
Part I Language Core 7 The first part of this book is a complete introduction to the core of the Objective Caml language, in particular the expression evaluation mechanism, static typing and the data
Weiss Chapter 1 terminology (parenthesized numbers are page numbers)
Weiss Chapter 1 terminology (parenthesized numbers are page numbers) assignment operators In Java, used to alter the value of a variable. These operators include =, +=, -=, *=, and /=. (9) autoincrement
INF121: Functional Algorithmic and Programming
INF121: Functional Algorithmic and Programming Lecture 6: Polymorphism, Higher-order, and Currying Academic Year 2011-2012 In the previous episodes of INF 121 Basic Types: Booleans, Integers, Floats, Chars,
Functional Programming. Pure Functional Programming
Functional Programming With examples in F# Pure Functional Programming Functional programming involves evaluating expressions rather than executing commands. Computation is largely performed by applying
Harvard School of Engineering and Applied Sciences CS 152: Programming Languages
Harvard School of Engineering and Applied Sciences CS 152: Programming Languages Lecture 18 Thursday, March 29, 2018 In abstract algebra, algebraic structures are defined by a set of elements and operations
Functional Programming. Pure Functional Programming
Functional Programming Pure Functional Programming Computation is largely performed by applying functions to values. The value of an expression depends only on the values of its sub-expressions (if any).
Introduction to ML. Mooly Sagiv. Cornell CS 3110 Data Structures and Functional Programming
Introduction to ML Mooly Sagiv Cornell CS 3110 Data Structures and Functional Programming Typed Lambda Calculus Chapter 9 Benjamin Pierce Types and Programming Languages Call-by-value Operational Semantics
OCaml. History, Variants. ML s holy trinity. Interacting with ML. Base type: Integers. Base type: Strings. *Notes from Sorin Lerner at UCSD*
OCaml 1. Introduction Rapid introduction to what s in OCaml 2. Focus on Features Individually as Needed as Semester Progresses *Notes from Sorin Lerner at UCSD* History, Variants Meta Language Designed
Introduction to Programming Using Java (98-388)
Introduction to Programming Using Java (98-388) Understand Java fundamentals Describe the use of main in a Java application Signature of main, why it is static; how to consume an instance of your own class;
Type Checking and Type Equality
Type Checking and Type Equality Type systems are the biggest point of variation across programming languages. Even languages that look similar are often greatly different when it comes to their type systems.
CS558 Programming Languages
CS558 Programming Languages Fall 2016 Lecture 3a Andrew Tolmach Portland State University 1994-2016 Formal Semantics Goal: rigorous and unambiguous definition in terms of a wellunderstood formalism (e.g.
CS1622. Semantic Analysis. The Compiler So Far. Lecture 15 Semantic Analysis. How to build symbol tables How to use them to find
CS1622 Lecture 15 Semantic Analysis CS 1622 Lecture 15 1 Semantic Analysis How to build symbol tables How to use them to find multiply-declared and undeclared variables. How to perform type checking CS
LECTURE 16. Functional Programming
LECTURE 16 Functional Programming WHAT IS FUNCTIONAL PROGRAMMING? Functional programming defines the outputs of a program as a mathematical function of the inputs. Functional programming is a declarative
It is better to have 100 functions operate one one data structure, than 10 functions on 10 data structures. A. Perlis
Chapter 14 Functional Programming Programming Languages 2nd edition Tucker and Noonan It is better to have 100 functions operate one one data structure, than 10 functions on 10 data structures. A. Perlis
CSE 341, Autumn 2005, Assignment 3 ML - MiniML Interpreter
Due: Thurs October 27, 10:00pm CSE 341, Autumn 2005, Assignment 3 ML - MiniML Interpreter Note: This is a much longer assignment than anything we ve seen up until now. You are given two weeks to complete
A general introduction to Functional Programming using Haskell
A general introduction to Functional Programming using Haskell Matteo Rossi Dipartimento di Elettronica e Informazione Politecnico di Milano rossi@elet.polimi.it 1 Functional programming in a nutshell
CS 360: Programming Languages Lecture 10: Introduction to Haskell
CS 360: Programming Languages Lecture 10: Introduction to Haskell Geoffrey Mainland Drexel University Thursday, February 5, 2015 Adapted from Brent Yorgey s course Introduction to Haskell. Section 1 Administrivia
CS558 Programming Languages. Winter 2013 Lecture 3
CS558 Programming Languages Winter 2013 Lecture 3 1 NAMES AND BINDING One essential part of being a high-level language is having convenient names for things: variables constants types functions etc. classes
INTRODUCTION TO HASKELL
INTRODUCTION TO HASKELL PRINCIPLES OF PROGRAMMING LANGUAGES Norbert Zeh Winter 2018 Dalhousie University 1/81 HASKELL: A PURELY FUNCTIONAL PROGRAMMING LANGUAGE Functions are first-class values: Can be
Recap. Recap. If-then-else expressions. If-then-else expressions. If-then-else expressions. If-then-else expressions
Recap Epressions (Synta) Compile-time Static Eec-time Dynamic Types (Semantics) Recap Integers: +,-,* floats: +,-,* Booleans: =,
G Programming Languages Spring 2010 Lecture 8. Robert Grimm, New York University
G22.2110-001 Programming Languages Spring 2010 Lecture 8 Robert Grimm, New York University 1 Review Last time Types Fun with O Caml 2 Outline Modules Sources: PLP, 3.3.4, 3.3.5, 3.7 Barrett. Lecture notes,
Programming Language Concepts, cs2104 Lecture 04 ( )
Programming Language Concepts, cs2104 Lecture 04 (2003-08-29) Seif Haridi Department of Computer Science, NUS haridi@comp.nus.edu.sg 2003-09-05 S. Haridi, CS2104, L04 (slides: C. Schulte, S. Haridi) 1
Thinking Induc,vely. COS 326 David Walker Princeton University
Thinking Induc,vely COS 326 David Walker Princeton University slides copyright 2017 David Walker permission granted to reuse these slides for non-commercial educa,onal purposes Administra,on 2 Assignment
Programming Languages and Compilers (CS 421)
Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC https://courses.engr.illinois.edu/cs421/fa2017/cs421d Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul
4/19/2018. Chapter 11 :: Functional Languages
Chapter 11 :: Functional Languages Programming Language Pragmatics Michael L. Scott Historical Origins The imperative and functional models grew out of work undertaken by Alan Turing, Alonzo Church, Stephen
Programming Languages
CSE 130: Spring 2010 Programming Languages Lecture 3: Epressions and Types Ranjit Jhala UC San Diego A Problem fun -> +1 Can functions only have a single parameter? A Solution: Simultaneous Binding Parameter
So what does studying PL buy me?
So what does studying PL buy me? Enables you to better choose the right language but isn t that decided by libraries, standards, and my boss? Yes. Chicken-and-egg. My goal: educate tomorrow s tech leaders
Lists. Prof. Clarkson Fall Today s music: "Blank Space" by Taylor Swift
Lists Prof. Clarkson Fall 2017 Today s music: "Blank Space" by Taylor Swift I could show you incredible things // Magic, madness, heaven, sin So it's gonna be forever // Or it's gonna go down in flames
Introduction to ML. Mooly Sagiv. Cornell CS 3110 Data Structures and Functional Programming
Introduction to ML Mooly Sagiv Cornell CS 3110 Data Structures and Functional Programming The ML Programming Language General purpose programming language designed by Robin Milner in 1970 Meta Language
CMSC 330: Organization of Programming Languages. OCaml Data Types
CMSC 330: Organization of Programming Languages OCaml Data Types CMSC330 Spring 2018 1 OCaml Data So far, we ve seen the following kinds of data Basic types (int, float, char, string) Lists Ø One kind
Questions? Static Semantics. Static Semantics. Static Semantics. Next week on Wednesday (5 th of October) no
Questions? First exercise is online: http://www.win.tue.nl/~mvdbrand/courses/glt/1112/ Deadline 17 th of October Next week on Wednesday (5 th of October) no lectures!!! Primitive types Primitive value
CSC312 Principles of Programming Languages : Functional Programming Language. Copyright 2006 The McGraw-Hill Companies, Inc.
CSC312 Principles of Programming Languages : Functional Programming Language Overview of Functional Languages They emerged in the 1960 s with Lisp Functional programming mirrors mathematical functions:
Handout 2 August 25, 2008
CS 502: Compiling and Programming Systems Handout 2 August 25, 2008 Project The project you will implement will be a subset of Standard ML called Mini-ML. While Mini- ML shares strong syntactic and semantic
1. true / false By a compiler we mean a program that translates to code that will run natively on some machine.
1. true / false By a compiler we mean a program that translates to code that will run natively on some machine. 2. true / false ML can be compiled. 3. true / false FORTRAN can reasonably be considered
CMSC330 Fall 2016 Midterm #1 2:00pm/3:30pm
CMSC330 Fall 2016 Midterm #1 2:00pm/3:30pm Name: Discussion Time: 10am 11am 12pm 1pm 2pm 3pm TA Name (Circle): Alex Austin Ayman Brian Damien Daniel K. Daniel P. Greg Tammy Tim Vitung Will K. Instructions
ITT8060: Advanced Programming (in F#)
based on slides by Michael R. Hansen ITT8060: Advanced Programming (in F#) Lecture 2: Identifiers, values, expressions, functions and types Juhan Ernits Department of Software Science, Tallinn University
COMP 150-AVS Fall OCaml and Functional Programming
COMP 150-AVS Fall 2018 OCaml and Functional Programming!1 Dialects of ML ML (Meta Language) Univ. of Edinburgh,1973 Part of theorem-proving system LCF (Logic of Computable Functions) SML/NJ (Standard ML
CS 11 Ocaml track: lecture 3
CS 11 Ocaml track: lecture 3 n Today: n A (large) variety of odds and ends n Imperative programming in Ocaml Equality/inequality operators n Two inequality operators: and!= n Two equality operators: