Introduction

Last week, we defined a type to be a set of values. Example types include int's, float's, String's, etc.
We said a type system consists of a means to define types and associate types with language constructs and consists of a set of rules for type equivalence, type compatibility, and type inference.
We classified several common types: boolean, character, numeric, enumeration, subrange, and composite.
We then looked at several common kinds of composite types: records, variant records, arrays, sets, pointers, lists, and files.
We discussed how several of these are implemented.
We looked at two different ways to define type equivalence: structural equivalence, and name equivalence, then talked about type conversion.
We begin today by looking at type compatibility and then at type inference.

Type Compatibility

Most languages do not require equivalence of types to use a value in a context. Instead, a value's type must just be compatible with that context.
So in an assignment, the r-value must be compatible with the l-value; if we are using + the two operands must be compatible with some common type that can be added.
Each language defines compatibility slightly differently.
For example, in Ada two types, S, T, are compatible if:
1. S and T are equivalent
2. One is a subtype of the other (or both are subtypes of the same base type)
3. Both are arrays, with the same numbers and types of elements in each dimension
Pascal relaxes the above slightly to allow integers to be used in contexts where a real was expected.
Whenever a language allows a value of one type to be used in a context that expects another, the language implementation must perform a type coercion, an automatic, implicit conversion to the expected type.

For example,

int i=5;
float a = 3.2;
a += i; //type coercion occurs

Type Inference

Type inference is the process of determine an overall type of an expression.
Let's write a:T to say a is of type T. We use the notation `T->S` to indicate the type of function from elements of type T to those of type S.
As an example of type inference, suppose `a:T`, `f:T->S`, then we can infer the expression `f(a)` will have type `S`.
Aside: It is no coincidence this looks like modus ponens rule from logic: `frac{T, T->S}{S}`, there is actually a connection between proofs and types inference of programs called the Curry Howard correspondence.

More on Type Inference

In assigning an overall type to an expression, we usually begin by assigning types to the leaves. Leaves will typically either get a type of some known type (a type constant) such as: int, float, String, etc, or if we don't yet know the type will initially be typed with a type variable: (S,T, ...).

For example, consider:

int a; //in a type we keep track of the type of a as being int
7.5; // when the compiler sees the expression 
    // it recognizes a float literal
7 * 3.14; // determines 7 is an int literal, 3.14 is a float literal

To compute an overall type of 7 * 3.14 the compiler would need to find some operator implementation of * compatible with input (int, float).
We note * might be overloaded (might have different implementations). One of these is *: (float, float) `->` float.
We note the compiler can determine that int is compatible with being coerced to float, so the expression (int, float) unifies with (float, float) under the mapping `i\n\t -> (float)\i\nt`, hence *(7, 3.14) has type float.
In general, the process of determining types of internal nodes of expression trees, will involve unifying the types of the arguments for the internal node with the types that node's label expects.
If this cannot be done there a type error/type inconsistency occurs, and the compiler will typically give an error message.

Type Checking

Type checking a program involves determining if a program has any type inconsistencies.
For example, in Ocaml (a relative pure functional language), this is done by checking:
- All occurrences of the same identifier (subject to scope rules) have the same type.
- In an if. . . then . . . else expression, the condition is of type bool, and the then and else clauses have the same type.
- A programmer-defined function has type 'a -> 'b -> . . . -> 'r, where 'a, 'b, and so forth are the types of the function's parameters, and 'r is the type of its result (the expression that forms its body). Note: this relies on viewing functions of multiple arguments `'a times 'b -> 'r` as being equivalent to `'a -> 'b -> 'r` (Currying).
- When a function is applied (called), the types of the arguments that are passed are the same as the types of the parameters in the function's definition.

Quiz

Which of the following statements is true?

Given two values, type compatibility is the problem of determining if they are of the same type using the type systems rules.
Polymorphisms refers to code that is designed to work with multiple kinds of types.
If two types are equivalent via structural equivalences, they will be equivalent via name equivalence.

Functional Programming

We are now going to talk about functional programming languages.
These programming languages view programs as functions.
Given two sets X,Y a function f associates to each value in X a value in Y.
This might be written f: X → Y
The mapping of a particular value might be written y = f(x).
In order to make a language out of the notion of function. We need
1. to be able to start with a base set of functions and define new ones;
2. we need to be able to apply functions to values.

More Functional Programming

In mathematics, variables always stand for actual values, there is no concept of memory location, and so you can't change the value of a variable.
In a pure functional programming language, we would similarly like that there are no variables, only constants, parameters (arguments to functions), and values.
We build up programs by defining functions of increasing sophistication in terms of previously defined functions.
The advantage to this approach would be that the language being close to mathematics would have programs which would be easier to verify the correctness of.
Most actual functional programming languages are not completely pure.

What about loops?

How can you do looping if you have a pure functional programming language?

for(int i=0; i <10; i++) {/*do something */}
Seems to require variables; however, we can replace it with recursion:
void my_for(int i, int stop, int step) {
    if ( i < stop) { /* do something */ 
        my_for(i+ step, stop, step)
    }
}
my_for(0, 10, 1);

Couldn't we just use C and write programs in a functional way?

Structured values such as arrays and records cannot be returned values from functions. -- so we end up messing around with pointers and worrying about bounds on things like arrays.
It is hard to build a value of a structured type directly. Functional languages, like ML, provide direct mechanisms for creating recursive data type like binary trees, etc.
Functions are not first class values. So it is hard to write the function h = comp(f,g) a function which take functions f and g as arguments and outputs their composition.

Scheme

Scheme was developed in the 1970s at MIT by Guy Lewis Steele Jr. and Gerald Jay Sussman as a variant of LISP for teaching purposes.
Because the Common LISP standard was only adopted in the 1980s, 20+ years after the creation of the first LISP interpreters, and because it was a very big language, Scheme carved out a niche.
Further, there was a very influential book from MIT: Structure and Interpretation of Computer Programs (Abelson, Abelson, Sussman) that used it.
Specifications of the Scheme language can be found at: http://scheme-reports.org/. The first Report on Scheme (1975) can be abbreviated (R0RS), the next one was called Revised Report on Scheme (R1RS), then the Revised Revised Report on Scheme (R2RS), etc.
For this class, we will use ChezScheme, originally developed by R. Kent Dybvig at Cadence Research Systems in 1984.
Cadence was later acquired by Cisco who are the current maintainers. They open-sourced it in 2016.
Chez Scheme supports the R6RS Scheme Specification ((2007).
The most recent specification of Scheme is R7RS. So far only the small version of the specification has been released (2013).
Racket is another closely related language to Scheme that was originally called DrScheme/PLTScheme.
It is popular because it come with a very nice IDE.
Racket extends the R5RS Scheme Specification (1998), so also should largely be okay for the homeworks.
DrScheme was created by Matthias Felleisen in 1995.

Syntax of Scheme

All programs in Scheme are expressions, expressions come in two varieties:
- atoms -- numbers, strings, names, functions, etc
- lists -- a sequence of expressions separated by spaces and surrounded by parentheses.

Here is a grammar for expressions:

<expression> ::= <atom> | <list>
<atom> ::= <number> | <string> | <identifier> | <character>| <boolean>
<list> ::= '(' <expression-sequence> ')'
<expression-sequence> ::= <expression> <expression-sequence> | <expression>

Expressions and Evaluation

42   - a number
"hello" - a string
#t - a Boolean true
#\a - the character 'a'
(2.1 2.2 3.1) - a list of numbers
a - an identifier
hello - another identifier
(+ 2 3) - a list consisting of the identifier "+" and two numbers
(* (+ 2 3) (- 4 3) ) - a list consisting of an identifier and two lists

To evaluate expressions we use the rules:

Constant atoms evaluate to themselves
Identifiers are looked up in the current environment and replaced by the value found there
A list is evaluated by first evaluating each of its elements. The first element in the list must evaluate to a function. This function is then applied to each of the remaining arguments.

More on Evaluation

So for example, + in (+ 2 3) evaluates to a procedure for addition, 2 evaluates to 2, 3 evaluates to 3. The procedure for addition is then applied to the rest of the list to get 5.
Evaluating all of the arguments before applying the function at the root of the expression (in this case +) is called applicative order evaluation.
Consider (2.1 2.2 2.3) . The number 2.1 is not a function, evaluating this list would give an error.
To prevent a list from being evaluated you can write either (quote 2.1 2.2 2.3) or in shorthand '(2.1 2.2 2.3).
eval is the opposite operation so (eval (quote (+ 2 3))) yields 5. Technically, in the official standard you need to write this as: (eval (quote (+ 2 3)) (scheme-report-environment 5)) where (scheme-report-environment 5) returns the environment binding provided by the version 5 revision of the ANSI standard.

Conditionals in Scheme

If statements:

(if (= a 0) (display "zero") (display "not zero"))
; display echoes to current output
; semicolon is used for comments
cond (sorta like switch/case):
(cond ((= a 0) (display "zero")) 
          ((> a 0) (display "bigger than zero"))
          ((= a -1) (display "minus one"))
          (else (display "less than -1")))

Notice neither if or cond use applicative order evaluation. Instead, they use some kind of delayed evaluation.

let

Scheme has function called let which allows values to be given temporary names within an expression:
```
(let ((a 2) (b 3)) (+ a b)) ; evaluates to 5
```
The first expression within let is called a binding list.

Adding things to the Scheme Environment

The define function can be used to add new associations between names and values in Scheme:

(define a 2)
(define emptylist '())
(define (sum lo hi) ; could write: sum (lambda (lo hi) ...
    (if (= lo hi)
         lo
         (+ lo (sum (+ lo 1) hi))) )

Once something has been define can see its value are scheme prompt

>(sum 3 5)
12

Loading a File in Scheme

Typically, Scheme programs are put in files with the extension .scm.
To load such a file we could use the load function:
```
(load "my-scheme-file.scm")
```
You can use load within a file to include one file in another one.
This will work in R5RS (so both modern Scheme and Racket).

In R6RS, you can use (import ...) to import a library:

(import (my-library)) ; current folder my-library.scm or my-library.sls 
;or
(import (foo my-library)) ; ./foo/my-library.scm or ./foo/my-library.sls

There are some implementation specific issues on the path search, so if you want to force it to do as above, you can add:
```
(import (rnrs) (my-library))
```

To define a library in Scheme, we can use (library ...):

(library (two-function)
  (export hello foo) ; these will be available outside library
  (import (rnrs))
  (define (hello) (display "hello"))
  (define (foo) (display "foo"))
  (define (bob) (display "bob")) ; not available outside library
)

Finish Types; Functional Programming, Scheme

Outline