More Scheme

CS152

Chris Pollett

Nov 10, 2021

Outline

Boolean Operations
let - begin
Data Structures in Scheme
In-Class Exercise
High-Order Functions
Closures

Introduction

Last day, we were talking about pure functional programming languages, one of the main features of which is that such a language does not have variables.
We talked about a function being referentially transparent if its values only depends on its arguments; I.e., no static variables.
Such pure languages are easier to prove correctness properties of their programs.
We said although no language is strictly pure some languages like Scheme, ML, Haskell are closer to purely functional.
We introduced Scheme, talked about expressions, evaluation, if, and cond.

Boolean Operations

There are a number of functions which can be used to compare objects in Scheme.
For numbers, we have already seen <, >, <=, >=. For example, (< 2 3 ) returns #t
For equality one have eq?, eqv?, and equal? The first is somewhat implementation dependent, the second checks if the two items are equivalent (essentially refer to the same value), the last does a deep comparison.
Notice the convention that "?" is used after functions which might return a true or false. Other, boolean functions: null?, string=?, number?, etc.
Scheme also has the Boolean operators and, or, not.

let and begin

We saw last day, Scheme has a 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.
You could view let as short for ((lambda (a b) (+ a b)) 2 3)
You could have multiple expressions not just (+ a b) at the end of a let (you can also do this with lambda) If you don't need to do any assignments, another useful Scheme operation which essentially does this is begin:
```
(begin l1 l2 l3 ...)
```
This executes l1 followed by l2 followed l3. You could view this as short for:
```
((lambda () l1 l2 l3 ...) )
```

Data Structures in Scheme

The basic data structure in Scheme is the list.
List can be nested to create more complicated structures.
For instance, ((a b) (c d) e).

There are three built-in functions to manipulate lists: car, cdr, cons -- the names correspond to assembly instructions on a now defunct IBM mainframe.

(car '(1 2 3)) ; returns 1 - the head of the list
(cdr  '(1 2 3)) ; returns (2 3) the tail of the list
(cons 0 '(1 2 3)) ;  adds to the front of the list (0 1 2 3 4)

What is (cons 'a 'b) ? Notice 'b is not a list. It is a so-called dotted pair: (a . b).
In general, a list is short for the corresponding nesting of a dotted pairs that begins with '(). So (b) is (b . '())
The function list can be used to make a list out of a collection of objects (list 'a 'b 'c) makes the list (a b c).

Doing Things Recursively

One can use recursion to do an operation on all the elements of a list or data structures derived from it:

(define (my-reverse-list L)
    (if (null? L) '()
         (append (my-reverse-list (cdr L)) (list (car L)))))

Recursion is often viewed as wasteful of space and time because it requires storage on the stack, and the push and popping from the stack takes times.
Modern translators can recognize certain kinds of recursions as being amenable for conversion to loops: those where the last operation in the procedure is a call to itself. (a tail recursive procedure).

Doing Things Recursively 2

One trick for making a procedure tail recursive is make use of an auxiliary function with an extra accumulating parameter:

(define (reverse-aux L list-so-far)
    (if (null? L) list-so-far
         (reverse-aux (cdr L) (cons (car L) list-so-far)))) ; tail-recursive
(define (my-reverse L) (reverse-aux L '()))

In-Class Exercise

Write a tail-recursive Scheme function ip which takes two lists and computes their inner-product
So (ip '(1, 2, 3) '(2, 3, 4)) outputs 1*2 + 2*3 + 3*4 = 20.
If a list element has number? equal #f treat it as 0. Also, if one list is shorter than the other treat its remaining elements as 0.
Please post your solution to the Nov 10 In-Class Exercise Thread.

Higher Order Functions

We said that functional programming languages allow us to treat functions as first class objects.
We've already seen one way that Scheme allows this: We can talk about functions independent of assigning them a name using lambda:
```
((lambda (x) (* x x)) 3) ; gives 9
```
We can also write functions that take functions as arguments:
```
(define compose (lambda (f g) (lambda (x) (g (f x)))))
```
There are some built in functions of this kind. For instance, (map f L) applies the function f to each element of L.

Closures

Consider

(define make-new-balance (lambda (balance)
    (lambda (amount)
        (if (< balance amount) "insufficient funds"
        (begin
             (set! balance (- balance amount))
             balance)))))
(define atm (make-new-balance 100))
(atm 20)
; returns 80

You can think of set! as altering the parameter list associated with the function returned by make-new-balance changing the value stored for balance within it. I.e., balance, is acting as a static variable and this is achieved using higher-order functions.
Another way to say this is, this function remembers the value of balance from the scope in which it was originally defined.
A function which can access the bound variables from the scope in which it is defined is called a closure.