Programming language--week1(sml)

1. Syntax:
   if e1 then e2 else e3
   where if ,then, and else are keywords and
   e1, e2, and e3 are subexpressions
   Type-checking:
   first e1 must have type bool
   e1 and e3 can have any type(let’s call it t) ,but they must have the type t
   the type of the entire expression is also t;
   Evaluation rules:
   first evaluate e1 to a value call it v1
   if it’s true, evaluate e2 and that result is the whole expression’s result
   else, evaluate e3 and that result is the whole expression’s result
2. The REPL
   (1)Read-Eval-Print-Loop is well named
   (2)Can just treat it as a strange/convenient way to run programs
   $\cdot$But more convenient for quick try-something-out
   $\cdot$Then move things over to a testing file for easy reuse
   (3)For reasons discussed in next segment, do not use ‘use ’ without restarting the REPL session
   $\cdot$ (But using it for multiple files at beginning of sessions is okay)
3. Tuples and lists
   So far: numbers, booleans, conditionals,variables, functions
   $\cdot$ Now ways to build up data with multiple parts.
   $\cdot$ This is essential
   $\cdot$ Java examples: classes with fields, arrays.
   Now:
   $\cdot$ Tuples: fixed “number of pieces” that may have different types.
   Coming soon:
   $\cdot$ Lists: any “number of pieces” that all have the same type.
   Later:
   $\cdot$Other more general ways to create compound data.
   3.1 Pairs(2-tuples)
   Need a way to build pairs and a way to access the pieces.
   (1)Build:
   $\cdot$ Syntax: $(e1,e2)$
   $\cdot$ Evaluation: Evaluate $e1$ to $v1$ and $e2$ to $v2$;result is $(v1,v2)$. A pair of value is a value.
   $\cdot$ Type-checking: If $e1$ has type ta and $e2$ has type tb,then the pair experssion has type ta * tb. A new kind of type.
   (2) Access:
   $\cdot$ Syntax: #1 e and #2 e
   $\cdot$ Evaluation: Evaluate e to a pair of values and return first or second piece.
   $\cdot$: Example: If e is a varible x,then look up x in environment.
   $\cdot$ : Type-checking:If e has type ta * tb, then #1 e has type ta.
   and #2 e has type tb.
   (3) Nesting
   Pairs and tuples can nested however you want.
   Not a new feature: implied by the syntax and semantics
   val x1 = (7, (true, 9)) (* int * (bool * int ) *)
   val x2 = #1 (#2 x1) (* bool *)
   val x3 = (#2 x1) (* bool * int * )
   val x4 = ((3,5), ((4,8), (0, 0) ) )
   ( * (int * int ) * ((int * int ) * (int * int)) *)
4. Lists
   $\cdot$ Despite nested tuples, the type of a varible still “commits” to a particular “amount” of data.
   In contract, a list:
   $\cdot$ Can have any number of elements
   $\cdot$ But all list elements have the same type.
   4.1 Building Lists
   (1) $\cdot$ The empty list is a value: [ ]
   (2)In general, a list of values is a value; elements separated by commas:
   $[v_1, v_2, ..., v_n]$.
   (3)If $e_1$ evaluates to $v$ and $e_2$ evaluates to a list $[v_1, ..., v_n]$,
   then$e_1::e_2$ evaluates to $[v,v_1..., v_n]$.
5. Accessing Lists
   Until we learn pattern-matching, we will use three standard-library functions.
   $\cdot$ null $e$ evaluates to true if and only if $e$ evaluates to [].
   $\cdot$ is $e$ evaluates to $[v_1, v_2,... , v_n]$ then hd(head) $e$ evaluates to $v_1$.
   $\cdot$ If $e$ evaluates to $[v_1, v_2,..., v_n]$ then tl(tail) $e$ evaluates to $[v_2,.., v_n]$
   (raise exception if e evaluates to [])
   (Notice result is a list)
   5.1 Type-checking list operations.
   (1) Lots of new types: For any type t ,the type t list describes lists where all elements have type t;
   (2) So [] can have type t list for an type.SML uses type ‘a list to indicate this (“quate a” or “alpha”).
   (3) For $e_1 ::e_2$ to type-check, we need a t such that $e_1$ has type t and $e_2$ has type t list. Then the result type is t list.

6. Let-expressions
   3 questions :
   $\cdot$ Syntax: let $b_1, b_2 ...b_n$ int $e$ end
   (1) Each $b_i$ is any bingding and $e$ is any expression
   (2)Type-checking: Type-check each $b_i$ and $e$ in a static environment that includes the previous bindings.
   Type of whole let-expression is the type of $e$
   (3) Evaluation: Evaluate each $b_i$ and $e$ in a dynamic environment that includes the previous bindings.
   Result of whole let-expression is result of evaluating $e$.

7. Options
   (1) t option is a type for any type t
   ($\cdot$ much like t list , but a different type, not a list)
   (2) Building:
   $\cdot$ NONE has type ‘a option (much like [] has type ‘a list)
   $\cdot$ SOME e has type t option if e has type t (much like e:: [])
   (3) Accessing:
   $\cdot$ isSome has type ‘a option ->bool
   $\cdot$ valOf has type ‘a option ->’a (exception if given NONE)

8. Boolean operations
   $e_1$ andalso $e_2$
   $\cdot$ Type-checking: $e_1$ and $e_2$ must have type bool
   $\cdot$ Evaluation: If result of $e_1$ is false then false else result of $e_2$
   $e_1$ orelse $e_2$ , not $e_1$
9. Comparisons
   For comparing int values:
   $= , <>, > , < , >=, <=$
   $\cdot$ can be used with real, but not 1 int and 1 real
   $\cdot$ =, <> can be used with any “equality type “but not with real