Expanded Recursive Diagrams OCAML rapid tour, day 2 Class 18 Expanded Recursive Diagrams OCAML rapid tour, day 2

Note This week's HW is in Racket; this week's Lab gives you a chance to play with Ocaml and make sure you've got it set up and working on your own computer. We'll just have to be bilingual for a little while The design recipe applies to Ocaml programs, too, with slight variations: Type signature is part of the code, not the comments Type-descriptions (like "a database is a list of 2-element string lists") are now mostly in code, not comments Exception: "A set is a list without repetitions": about contents, not structure check_expect is now spelled with an underscore, and it's not as fancy as the one in Racket.

Expanded recursive diagrams

A new part of the problem: from OI to RI Example: fold OI: +, 0, (list 3 2 1) how do we get to the recursive input??? RI: +, ???, (list 2 1) RO: 6 just copy recursive output to overall output! OO: 6

A new part of the problem: from OI to RI Example: fold OI: +, 0, (list 3 2 1) copy the proc; take "rest" of list; for "init", combine it with (first alod) using "proc" RI: +, 3, (list 2 1) RO: 6 just copy recursive output to overall output! OO: 6

OCaml tour continued: back to lecture 8, and length of a list

A minor difference between OCaml and Racket In OCaml, there's no "define", only "let" and "let rec" let x = 5 <remainder of program> is like (let ((x 5)) (remainder of program)) i.e., the let-binding remains in force for everything below it.

Writing a recursive procedure # let rec myLen (lst: 'a list):int = match lst with | [] -> 0 | hd::tl -> 1 + myLen tl;; match…with is the new "cond" | is used to indicate various cases -> is used to separate the case-selection from the associated value Some clever name-assignment goes on too let rec is used instead of "define"

Let's work up to that a little more slowly…

Review of types (and a few more) Atomic types: int, float, bool, string, char Tuples: (3, “a”) : int * string. (4.0, ‘b’) : float * char Lists: [], ::, [ ; ; ] Parameterized type: int list, string list, etc. Generic: ‘a list

More types Variant types (more details later) type season = Fall | Winter | Spring | Summer type base = A | T | C | G type card = Clubs of int | Hearts of int | Spades of int | Diamonds of int type racket_value = | Number of int | Boolean of bool | String of string | Builtin of ??? | User_proc of (string list) * expression * (binding list) Things on the right ('constructors') must start with a capital Things on left (type-names) must start lowercase

Even more types Parameterized variant types: type ‘a tree = | Leaf | Node of ‘a * ‘a tree * ‘a tree Records (which we will almost never use) another alternative to structs, but with no useful form for pattern matching; can also be thought of as “tuples with names for the parts”. type point_3d = {x : int; y : int; z : int} # let origin3 = ({x = 0; y = 0; z = 0} : point_3d) # origin.z # − : int = 0

Pattern matching Replaces the main “cond” in most procedures A “match expression” looks like this: match <expr> with | pattern1 -> result1 | pattern2 -> result2 … Allowable patterns: constants, identifiers, tuples of patterns, constructors with dummy arguments, wildcards Constructor example: Hearts n Matches Hearts 3 Temporarily makes n be 3 Can refer to n in the “result” expression! Combines “cond” and part-extraction and “let” all in one!

Pattern matching Allowable patterns: constants, identifiers, constructors with identifier arguments, wildcards Constant example: 14 Matches only the number 14 Wildcard example: Hearts _ Matches anything, but the matched thing has no name to let you use it Identifier examples: n (matches anything) Hearts r

Pattern matching idioms match lst with | [] -> 0 | hd::tl -> hd + myfunc tail;; | hd::_ -> 2*hd;; match (s:season) with | Fall -> 68 | Winter -> 34 | Summer -> 85 | Spring -> 65

Pattern matching idioms: using the matched item as well as the pattern match lst with | [] -> 0 | hd::tl -> hd + List.length lst;;

Pattern matching tuples match pair with | (a, b) -> something involving a and b Serves as an easy way to tease apart a tuple and give names to all the pieces. | (true, b) -> something involving b | (_, a) -> 14 * a Another way to break into various cases

Pattern matching with conditions match num with | n when n < 3 -> 11 | n -> 22

Imagine implementing Ocaml in Racket…types You might represent each value as a list of two items: (list "int" 37) (list "string" "hello") (list "Cons" (list 1 2 3)) (list "Empty" empty) (list "Clubs" 4) ;; represents 4 of clubs Hmmm. Is the first item in our list the type of the item, or the constructor that was used to construct it?

Let's make it a list of THREE elements (list "int list" "::" (list 1 2 3)) (list "int list", "[]" empty) (list "card" "Clubs" 3) (list "season" "Fall" <nothing>?) Now it's easy to see how "matching" could work: we say "if this card was constructed with the Club constructor, then produce this value; if it's a Heart then produce this

List recursion template let rec proc (alod : ’a list) : ’b = match alod with | [] -> ... | hd :: tl -> ... hd ... proc tl ... QUIZ: use this to write “length”

Syntactic Sugar let rec proc: ’a list -> ’b = function | [] -> ... | hd :: tl -> ... hd ... proc tl … let rec length: ’a list -> int = function | [] -> 0 | _ :: tl -> 1 + length tl;;

Natural number recursion template let rec proc (num: int) : ’b = match num with | 0 -> ... | n when (n > 0) -> ... num ... proc (n-1) ... | _ -> failwith “Proc: input isn’t a natural number” let rec proc: int -> ’b = function

Two-argument recursion template let rec proc (n: int) (alod: ‘alist) = match (num, alod) with | 0, [] -> ... | 0, hd::tl -> ... | n, [] when (n > 0) -> .. n .. proc.. (n-1) | n, hd::tl when (n > 0) ->..n..proc..(n-1)..hd..tl.. | _,_ -> failwith “Proc: input isn’t a natural number”

“let”, expanded We’ve seen “let” (analogous to define) and “let rec” (allowing definition of recursive things) let … and allows definitions of multiple things, as in let x = 1 and y = 2 Also available in let…rec form. let...in analogous to Racket let-expression (creates temporary bindings)" # let in x + y;; -: int = 3

Ocaml functions We’ve seen a bunch of “infix” functions, like “+” (which takes two ints and returns an int) These functions are written between their arguments We, too, can define infix functions…but we won’t. We’ll only define “prefix” functions, whose name goes before the argument. # let add17 (num:int):int = num + 17;; # add17 1;; -:int = 18 General forms: let (<id>:<type>):<type> = <expr> usually on next line let rec (<id>:<type>):<type> = <expr>

Lambda Can add type annotations: fun <ident> -> <expr> fun x –> x + 1 # (fun x -> x + 1) 2;; -: int = 3 Can add type annotations: fun (x:int) –> x + 1

let add17 = fun num -> num + 17 Syntactic sugar again In Racket, (define (f x)…) was really (define f (lambda (x) …)) In Ocaml, let add17 num = num + 17; is really let add17 = fun num -> num + 17

Multi-argument procedures In Ocaml fun x y -> x + y + 1 looks like a 2-arg function. It’s not. Let’s see: # fun x y -> x + y + 1;; - : int -> int -> int = <fun> The truth: it’s really syntactic sugar for # fun x -> (fun y -> x + y + 1);; : int -> int -> int = <fun> Rewriting multi-arg functions as nested one-arg functions is called « Currying »