# Local bindings

## Exercise 1

What are the values of the following `let`-expressions?

1. ```(let ((tone '(f a))
(call-me '(a l)))
(append call-me tone '(l) tone))
```
2. ```;; Solutions to the quadratic equation x^2 - 5x + 4:
;;
(let ((discriminant (- (* -5 -5) (* 4 1 4))))
(list (/ (+ (- -5) (sqrt discriminant)) (* 2 1))
(/ (- (- -5) (sqrt discriminant)) (* 2 1))))
```
3. ```(let ((total (+ 8 3 4 2 7)))
(let ((mean (/ total 5)))
(* mean mean)))
```

You may use DrScheme to help you answer these questions, but be sure you can explain how it arrived at its answers.

## Exercise 2

Write a nested `let`-expression that binds a total of five names, `a`, `b`, `c`, `d`, and `e`, with `a` bound to 9387 and each subsequent name bound to a value twice as large as the one before it -- `b` should be twice as large as `a`, `c` twice as large as `b`, and so on. The body of the innermost `let`-expression should compute the sum of the values of the five names.

## Exercise 3

Write a `let*`-expression equivalent to the `let`-expression in the previous exercise.

## Exercise 4

One of the traditional ways to compute the area of a triangle, given the lengths a, b, c of its sides, is to use Heron's formula:

A = √ (s · (s - a) · (s - b) · (s - c))

Here s is the semiperimeter of the triangle, (a + b + c) / 2.

Design and test a Scheme procedure that computes the area of a triangle, given the lengths of its sides, using Heron's formula.

## Exercise 5

Here is a procedure that takes a non-empty list of lists as argument and returns the longest of those lists (or one of the longest, if there is a tie).

```;;; longest-list-in-list: identify and return the
;;; longest list in a non-empty list of lists.

;;; Given:
;;;   LS, a list of lists.

;;; Result:
;;;   LONGEST, a list.

;;; Precondition:
;;;   LS is not empty.

;;; Postconditions:
;;;   (1) LONGEST is an element of LS.
;;;   (2) No element of LS is longer than LONGEST.

(define longest-list-in-list
(lambda (ls)
(if (null? (cdr ls))
(car ls)
(longer-list (car ls)
(longest-list-in-list (cdr ls))))))
```

This definition of the `longest-list-in-list` procedure includes a call to the `longer` procedure, which returns the longer of two given lists:

```;;; longer-list: return the longer of two given lists

;;; Givens:
;;;   LEFT and RIGHT, both lists.

;;; Result:
;;;   LONGER, a list.

;;; Preconditions:
;;;   None.

;;; Postconditions:
;;;   (1) LONGER is either LEFT or RIGHT.
;;;   (2) Neither LEFT nor RIGHT is longer than LONGER.

(define longer-list
(lambda (left right)
(if (<= (length right) (length left))
left
right)))
```

Revise the definition of `longest-list-in-list` so that the name `longer-list` is bound to the procedure that it denotes only locally, in a `let`-expression.

Note that there are two possible ways to do this: The definiens of `longest-list-in-list` can be a `lambda`-expression with a `let`-expression as its body, or it can be a `let`-expression with a `lambda`-expression as its body. Does the order of nesting affect what happens when the procedure is invoked? If so, which arrangement is better? Why?

I am indebted to Professor Ben Gum for his contributions to the development of this lab.