Class 20 Announcements/info Reason review, clarifications - - PowerPoint PPT Presentation

Class 20

Announcements/info Reason review, clarifications Dictionaries Variant Types Options

• Show of hands: how many are still having trouble with

installing VSCode for reason?

• Preferred type-annotation for functions:
• let f : (int => string) = …

• Reason so far:
• Basic types: int, float, string, bool, list(int), list('a), function

types, …

• Builtins: familiar by now
• "let" instead of (define…); each "let" opens a new

environment.

• Type-ascription: (x:int) means "x is an expression whose value

has type int"

A few more things about reason

• Modules
• Complex assignments/matching
• Blocks

A first look at modules

• We can collect multiple functions into a module (we can put types and

values in there too; more later)

• Module names start with a capital letter
• All the functions in Tank.re become part of the "Tank" module.
• So you've been defining modules all along without knowing it!
• To refer to a function – say, "testFull" in the Tank module, you write

Tank.testFull(…)

and Reason finds the relevant file, and uses the definition found there.

• You've already done this with List.rev
• Alternative: if you're going to be using "Tank" functions a lot, you can

say

• pen Tank;

testFull(…)

so that you no longer need to use the "Tank" prefix.

Assignment

• You've seen

let a = 4;

• You can also use (in assignments or in "switch" expressions)

let (a, b) = (2, 4);

• … to assign both parts at once
• If you want to ignore one of them, you can say

let (_, b) = (2, 4);

• Works in general. You can also write

let [hd, ...tl] = [1, 4, 5, 6]; to get hd -> 1, tl -> [4, 5, 6];

Type definitions

• Sometimes you keep using a type over and over. You can name new

types! type ibpair = (int, bool); type bignum = list(int);

• You can even make new types that allow multiple possibilities,

similar to list('a): type pair('a, 'b) = ('a, 'b); type ibpair = pair(int, bool); type matrix('a) = list(list('a));

Type definition limitations

• Some type definitions, like "matrix", don't include necessary

information, like "I only want nonempty lists, and the inner lists should be nonempty, too"

• A perfect place to add this is at the top of the design recipe,

in the data definition (just as you add constraints on values in the I/O specification: "myCount, a positive integer"

let expressions

• Racket:

(let ((x 5) (y 2)) (+ x y)) => 7

• Reason

{ let x = 5; let y = 2; x + y }; [result: the integer 7] x; [result: Unbound value x]

Block expressions

• The block itself has a value, the value of the last item in the

block

• It defines a "local environment", in which bindings are made

temporarily and then forgotten. let k = {let x = 5; let y = 2; x + y};

• k ends up bound to 7; x and y are undefined.
• Perfect application: helper functions!

Helpers inside blocks

type bignum = list(int); let bnAdd: (bignum, bignum) => bignum = (a, b) => { let bnAddHelper: … = … ; bnAddHelper(a, b, 0) };

Helpers inside blocks

type bignum = list(int); let bnAdd: (bignum, bignum) => bignum = (a, b) => { let bnAddHelper: … = … ; bnAddHelper(a, b, 0) };

Quiz: Fast-reverse

/* reverse the first list, and append to it the second */ let rec revHelper: (list('a), list('a)) => list('a) = (lst, rest) => switch(lst){ | [] => rest | [hd, ...tl] => revHelper(tl, [hd, ...rest]) }; let rev: list('a) => list('a) = lst => revHelper(lst,[]);

Quiz: rewrite let rev … using a block to "hide" revHelper. You don't need to copy any of the green stuff – just write "…"

"Or" types

• Mechanism for saying something can be this or that

type season = Fall | Winter | Spring | Summer let averageTemp: season => int = fun | Fall => 52 | Winter => 30 | Spring => 45 | Summer => 80;

• The "season" type has only four possible values, just as "bool" has
• nly two.
• The "constructors" must start with capital letters.

Fancier Or types

• Constructors can include some data

type news = Alert(string) | Normal(string); type myIntList = Empty | Cons (int, myIntList);

• The kind of data can be a parameter!

type myList('a) = Empty | Cons ('a, myList('a));

A simple dictionary “data structure”: a list of pairs.

let myDict = [(“I”, “je”); (“you”, ”tu”); (“dog”, “chien”); … ] : list(string*string) better: type dict = list(string * string); let myDict = [(“I”, “je”); (“you”, ”tu”); (“dog”, “chien”); … ] :dict;

let rec lookup: (string, dict) => string = (term, dictionary) => switch(dictionary) { | [] -> ???; | [(k, v), ... tl] -> if (term == k) then v else lookup(term, tail) };

Using a dictionary

type dict = list(string * string); let myDict = [(“I”, “je”); (“you”, ”tu”); (“dog”, “chien”); … ] :dict;

let rec lookup: (string, dict) => string = (term, dictionary) => switch(dictionary) { | [] -> ???; | [(k, v), ... tl] -> if (term == k) then v else lookup(term, tail) };

A builtin type for handling success/failure cases!

type option('a) = Some('a ) | None

• Intended use:
• “None” means something like “I didn’t find an answer” or “your item

isn’t in the data”, etc.

• “Some(x)” means “I found an answer, and it was x”
• Requires new type-signature for most functions

f: int => int becomes f: int => int option

For recursive procs, adds slight complexity

Small example

let rec lookup: (string, dict) => string = (term, dictionary) => switch(dictionary) { | [] -> None; | [(k, v), ... tl] -> if (term == k) then Some(v) else lookup(term, tail) };

Annoyance

• When you look up "dog", you get

Some("chien") not "chien"

“Sum up all ints in a list except 1s; if empty or nothing but 1s, return None”

let rec sumButOnes:(list(int) => option(int)) = fun | [] => None | [1, ...tl] => sumButOnes(tl) | [hd, ...tl] => switch (sumButOnes(tl)) { | None => Some(hd) | Some(s) > Some(hd + s) };