Introduction

Last Wednesday, we were continuing our discussion of the Scheme programming language.
We went over common boolean operations like: <, >, <=, >=, eq?, eqv?, equal?, null?, string?, ... and, or not.
We discussed sequence operations with and without a binding list, i.e., let and begin.
We went over the basic list operations of car, cdr, cons and discussed dotted pairs.
We went over a couple of examples of converting recursive function calls to tail recursive function calls.
We finished up talking about higher order functions in Scheme and closure.
We begin today, by looking at how the closure idea can be used as the basis for doing object orientation in Scheme.

Message Passing in Scheme

The basic way we can set up a class in Scheme is to define a constructor:

(define my-class (lambda (construct-arg1 ...)
      (let ((my-field1 val1) ; it is also legal to nest define's in Scheme
             (my-field2 val2) ...)
             (lambda (msg . args)
                  (cond ((eqv? msg msg1)
                             ;do-some-action
                             )...
                  ))))

We can then create an instance of the class using:

(define my-instance (my-class construct-val1 ...))

We can then pass messages to the instance using lines like:
```
(my-instance msg1 msg1-args)
```

Quiz

Which of the following statements is true?

Type inference is the process of determining if a program has any type inconsistencies.
The Curry Howard correspondence is a mapping between the types: `a times b -> r` and `a -> b -> r`.
It is possible to have a dotted pair that is not a list in Scheme.

Evaluation Order

Recall we said that when Scheme evaluates an expression like:
```
(* (+ 2 3) (- 4 3) )
```
it uses applicative order evaluation. That is, it evaluates all of its arguments before evaluating the procedure in an S-expression.
So it compute (+ 2 3), (- 4 3) before *.
In normal order evaluation (aka lazy evaluation), one tries to apply the operation first, with the arguments unevaluated and evaluate them only as needed.
As an example, consider the function:
```
(define double (lambda (x) (+ x x)))
```
Here is how (double (* 3 4)) would be evaluated first in applicative order, and second in normal order:
```
;Applicative order
(double (* 3 4)) 
=>(double 12)
=>(+ 12 12)
=>24
```
```
;Normal order
(double (* 3 4))
=>(+ (* 3 4) (* 3 4))
=>(+ 12 (* 3 4))
=>(+ 12 12)
=>24
```
In this case normal order evaluation causes us to do extra work.

Evaluation Order - A Second Example

There are cases though where normal order evaluation helps.

Consider the function:

(define switch
  (lambda (x a b c)
    (cond ((< x 0) a) 
          ((= x 0) b)
          ((> x 0) c))))

Here is how (switch -1 (+ 1 2) (+ 2 3) (+ 3 4)) would be evaluated first in applicative order, and second in normal order:

;Applicative order
(switch -1 (+ 1 2) (+ 2 3) (+ 3 4))
=> (switch -1 3 (+ 2 3) (+ 3 4))
=> (switch -1 3 5 (+ 3 4))
=> (switch -1 3 5 7)
=> (cond ((< -1 0) 3)
            ((= -1 0) 5)
            ((> -1 0) 7))
=> (cond (#t 3)
            ((= -1 0) 5)
            ((> -1 0) 7))
=> 3

;Normal order
(switch -1 (+ 1 2) (+ 2 3) (+ 3 4))
=> (cond ((< -1 0) (+ 1 2))
            ((= -1 0) (+ 2 3))
            ((> -1 0) (+ 3 4)))
=> (cond (#t (+ 1 2))
            ((= -1 0) (+ 2 3))
            ((> -1 0) (+ 3 4)))
=> (+ 1 2)
=> 3

In this case, normal order never needs to evaluate (+ 2 3) or (+ 3 4).

Expression Types

As we said a moment ago, Scheme uses applicative order for functions.
However, Scheme also has a notion of a special form. For example, cond is a special form.
Arguments to special forms are passed unevaluated, so special forms use normal order evaluation.
Together, special forms and functions are known as expression types in Scheme.
Scheme has mechanism to create new derived special forms (called macros) using define-syntax.

For example, the following code creates a new macro nil! which replaces the value of a variable with the empty list:

(define-syntax nil!
  (syntax-rules ()
    ((_ x) ; _ is abbreviating the name of the macro nil!
           ; so this says if see pattern (nil! x) 
           ; replace with next line.
           ; Here we only have one pattern, legal to have several
     (set! x '()))))

We can compare its behavior to the following function: f-nil!

(define (f-nil! x)
   (set! x '()))

(define a 1)
;Value: a

(f-nil! a)
;Value: 1

a
;Value: 1  
; the value of a does not change
; as value was changed only in scope of f-nil! function

(nil! a)
;Value: 1

a
;Value: ()         
; a becomes '()

Converting Arguments for Normal Order Evaluation

If we wanted to fake normal order evaluation for some function, you could imagine trying to send the arguments in to the function quote'd, and then only evaluate the arguments as needed.

We can use define-syntax to make a nice macro for this:

(define-syntax my-delay 
  (syntax-rules ()
    ((my-delay expr)
     (lambda ()
        expr))))

The opposite of my-delay is to force evaluation:
```
(define (my-force promise) (promise))
```

Scheme has built-in functions delay and force which do what are code above does. So:

(delay (+ 5 6)) ;return a promise
(let ((delayed (delay (+ 5 6))))
  (force delayed)) ; returns 11

Infinite Lists

A stream is an infinite list.
We can think of such a list as an initial sequence of elements we have values for together with a procedure to generate elements after these elements.

We can define cons-stream (stream analog of cons), head (stream analog of car), tail (stream analog of cdr) for streams as follows:

(define-syntax cons-stream
  (syntax-rules ()
    ((cons-stream x y)
     (cons x (delay y)))))
(define head car)
(define (tail stream) (force (cdr stream)))
(define empty-stream? null?)
(define the-empty-stream '())

We can use the above to create the natural numbers stream:

(define (integers-starting-from n)
 (cons-stream n 
  (integers-starting-from (+ n 1))))
(define nat-nums
  (integers-starting-from 1))

Some Built-in Functions

We will talk some more about evaluation order on Wednesday, for the rest of today I will talk about various built-in functions in Scheme:

Characters:
- Character literals can be written like: #\a, #\b, #\space, #\newline, etc. char=?, char<?, char-ci<?, char-alphabetic?, char-whitespace?, etc for comparing characters
- Case conversion: char-upcase, char-downcase
- Type conversion: char->integer, integer->char
String:
- String literals can be written like: "hi there" string=?, string<?, string-ci<?, etc, can be used for comparing strings.
- (string) - creates "", (string #\a #\b #\c) -creates "abc" etc.
- string-length - returns the length of a string
- (string-ref "hello" 3) returns 3rd char from "hello"
- (string-set! str 3 #\m) changes 3rd char of str (provided mutable) to m.
- string-copy - returns a copy of a string; string-append - concatenates the strings in its input;
- (substring string start end) returns a substring of given range.
- string->list - converts the string to a list consisting of its characters
- list->string - converts a list of chars to a string.

Vectors

Lists in Scheme are implemented in memory as linked-lists. So you need to traverse the first i-1 elements of a list to get to the ith element.
This can often be slow. Vectors in Scheme are more like arrays in other languages: They have a fixed number of elements, but they support random access look-up.
The notation for a vector is #(elt1 elt2 elt3).
(vector) - creates the empty vector #(); (vector 'a 'b) - creates #(a b)
(make-vector n) - creates a vector of length n; (make-vector n 'a) - creates a vector of length n all of whose elements are a.
vector-length - returns the length of a vector
(vector-ref vec n) - returns n elt of vec
(vector-set! vec n obj) - sets the nth elt of vec to obj
(list->vector list) - converts a list to a vector
(vector->list vec) - converts a vector to a list

Symbols

There are a couple functions which are useful to help one convert between strings and symbols:
```
(string->symbol "hi") outputs hi symbol
(symbol->string 'hi) outputs "hi" string
```

More Advanced Bindings - let*, letrec

Let has two more advanced variants:
- let* - this is like let, except that it process the variables in left-to-right order. Unlike let, this let's you use earlier defined variables in the definition of later ones:
```
(let ((x 2) (y 3))
  (let* ((x 11)
         (z (+ x y))) ; 11 + 3 = 14
    (* z x))) ; 11 * 14 = 154
```
- letrec - Like let, but unlike let*, the names in the binding list must be unique. Unlike let, letrec though evaluates the values of the bindings after all the names have been declared. This allows for mutually recursive bindings to be used.
```
(letrec ((even?
          (lambda (n)
            (if (zero? n)
                #t
                (odd? (- n 1)))))
         (odd?
          (lambda (n)
            (if (zero? n)
                #f
                (even? (- n 1))))))
  (even? 86)) ; #t 
```

Iteration - do, named let

For completeness, we briefly mention some constructs that let us do somewhat non-functional looping in Scheme:
- do - This acts a little like a for loop. It has the general format:
```
(do ((<variable1> <init1> <step1>)
   ...) (<test> <expression> ...) <command> ...)
```
  For example,
```
do ((vec (make-vector 5))
     (i 0 (+ i 1)))
    ((= i 5) vec)
  (vector-set! vec i i)) ; returns the vector #(0 1 2 3 4)
```
- named let - This has the format:
```
(let <variable> <bindings> <body>)
```
  The bindings are like a usual let expression. body is allowed, as in a normal let, to use these bindings, but it can also use variable as the name of a procedure. variable is bound to the procedure whose parameter list consists of the names from bindings and whose code is given by body. See the next slide for an example of using a named let.

Using Named Let to Split a String

(define (tokenize l delim)
  (let loop ((t '())
             (l l))
    (if (pair? l) ; checks if dotted pair
        (let ((c (car l)))
          (if (char=? c delim)
              (cons (reverse t) (loop '() (cdr l)))
              (loop (cons (car l) t) (cdr l))))
        (if (null? t)
            '()
            (list (reverse t))))))

(define (string-split s delim)
  (map list->string (tokenize (string->list s) delim))) 
  ; map takes a function f and a list (e1 e2 ... en) and computes 
  ; ((f e1) (f e2) ... (f en))

(string-split "hi there" #\space) ; returns ("hi" "there")

Input

Input and output in Scheme is done using ports which are first-class objects. Such as #<port>
These can be thought of as file handles in other languages.
(input-port? obj) - checks if obj is a port
(current-input-port) - returns the current input port; (set-current-input-port! port) - sets this port
(open-input-port filename) - opens the file and returns an input port to it.
(close-input-port input-port) - closes the input port.
(read port) - reads from input port. If at end of file returns an eof-object. If no port-supplied reads from current-input-port.
(eof-object? obj) - checks if obj is a an end of file object. read-char, peek-char, char-ready? Similar to read but for characters.

Output

Most of these functions have names analogous to the names for input functions: current-output-port, set-current-output-port!, output-port?, open-output-port, close-output-port.
To write, the functions are: (write obj port), (display obj port), (write-char char port), (newline port). If you do not have a port, then it defaults to the current one.

Scheme Message Passing - Built-in Functions

Outline