1. Develop the function without using local. For the purposes of this exercise, do not use any helper functions, nor the built-in Scheme function max.

   Stylistically what don't (or shouldn't) you like about this code?

2. Develop the function using local. Again, don't use a helper function, or max.

3. Try running each version on the following input (or longer ones):

   (list 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20) 

   What difference do you see?

4. For each version, determine how many calls to your function is made for the input

   (list 1 2 3 … n)

   for various values of n.

   Can you write a mathematical equation that describes this number of calls? (This exercise is a small example of what you'd learn to do in COMP 280.)

5. Develop a third version that does not use local, but does use Scheme's built-in max function. Is this version relatively efficient?

2. Develop a function that, given n and i normally returns the list of length i of numbers up to n:

   (list n-(i-1) … n-1 n)
             

   More concretely, e.g.,

   (nums-upto-help 5 0)        ⇒      empty
   (nums-upto-help 5 2)        ⇒      (list 4 5)
   (nums-upto-help 5 5)        ⇒      (list 1 2 3 4 5)
   (nums-upto-help 6 5)        ⇒      (list 2 3 4 5 6)
   (nums-upto-help 7 5)        ⇒      (list 3 4 5 6 7)
             

   For simplicity, you may assume that i≤n. This should just follow the template for natural numbers on i.

3. Your nums-upto-help repeatedly passed one argument unchanged to its recursive call. I.e., it's an invariant argument. Rewrite your function, adding a helper, hidden by local, which avoids having an invariant argument. Don't forget to include a contract and purpose for this new local function, too.

4. Develop the function we really want:

   (nums-upto 5)               ⇒       (list 1 2 3 4 5)

   Use your nums-upto-help to do most of the work.

5. Edit your code to use local to hide the helper nums-upto-help inside your main function nums-upto.

1. What does the following code do? Explain it in terms of the evaluation rule above.

   (define growth-rate 1.1)
   
   (define (grow n)
      (* n growth-rate))
   
   (local [(define growth-rate 1.3)]
      (grow 10))
   
   (grow 10)
             

   Confirm your understanding with DrScheme, with the Check Syntax button, and by evaluating the code.

2. Is the following code essentially different from the previous example? Why or why not?

   (define growth-rate 1.3)
   
   (define (grow n)
      (local [(define growth-rate 1.1)]
         (* n growth-rate)))
   
   (grow 10)
             

   Once again, confirm your understanding with DrScheme.

In each case, grow "knows" which placeholder named growth-rate was in scope when it was defined, because that knowledge is part of grow's closure.

As a result, first figure out without DrScheme what each example produces. To do so, you may want to use local's hand-evaluation rules above. Then confirm your results by using DrScheme.

(Note - Some examples give errors about unbound placeholders.)

• (define w 1)
  (define x 3)
  (define y 5)
  
  (local [(define w 2)
          (define x 4)
          (define z 6)]
     (+ w x y z))
  
  (+ w x y)
            

• (define w 1)
  (define x 3)
  (define (test x y)
     (local [(define w 2)
             (define x 4)
             (define z 6)]
        (+ w x y z))))
  
  (test 8 3)
  (test x w)
  (test w x)
            

• (define x 1)
  (define y 1)
  (local [(define x 2)
          (define y x)]
     (+ x y))
  (+ x y)
            

• Here is an example of mutually recursive functions following the template for natural numbers. It is motivated by the observation "a positive number n is even if n-1 is odd, a positive number n is odd if n-1 is even, and 0 is even."

  
  (local [; my-odd?: natnum --> boolean
          (define (my-odd? n)
             (cond [(zero? n)     false]
                   [(positive? n) (my-even? (sub1 n))]))
           
          ; my-even?: natnum --> boolean
          (define (my-even? n)
             (cond [(zero? n)     true]
                   [(positive? n) (my-odd? (sub1 n))]))]
  
     ; Now, the body of the local:
     (my-odd? 5))
  
  ; Outside the local:
  (my-odd? 5)
            

  Note that the two local functions are in each others' closure; they will always call each other, no matter how you define other placeholders with the same names my-even?. Also note that this is an example of mutually recursive functions, where the mutual recursion does not result from a mutually recursive data structure.

• (define x 1)
  (define y 2)
  
  (define (f x)
     (local [(define (g x) (+ x y))
             (define y 100)]
        (g (g x))))
  
  (local [(define x 30)
          (define y 31)
          (define (g x) (* x y))]
     (g 20))
  
  (g 20)
  (f 20)