CS 491 (Spring 2002) Homework 2

• Lambda Calculus

  • Using the lambda calculus interpreter found here, and using the given definitions of true, false, succ, pred, nil?, etc., use the Y-combinator to write a lambda expression, equals, with natural number argument, x, which returns a lambda expression with natural number argument, y, which returns true, if x=y, and returns false otherwise. For example, > true (lambda (x) (lambda (y) x)) > false (lambda (x) (lambda (y) y)) > (define one (reduce `(,succ ,nil))) > (define two (reduce `(,succ ,one))) > (reduce '((,equals ,one) ,one)) (lambda (x) (lambda (y) x)) > (reduce '((,equals ,one) ,two)) (lambda (x) (lambda (y) y)) >
  • Use the Y-combinator to write a lambda expression, fact, with natural number argument, x, which returns x!. For example, > (define answer (reduce '(,fact ,three))) > (reduce '((,equals ,answer) ,six)) (lambda (x) (lambda (y) x)) >

• Macros

  • Declare a macro with keyword and, which like or, may take any number of subexpressions. If called with no subexpressions, it is true. If all of its subexpressions are true, it evaluates to the last one; otherwise it is false.

  • Many Scheme's have a syntactic form called named-let. Named-let has the following abstract syntax:

    (let <name> ((<var1> <val1>)...(<varN> <valN>)) 
      <expr1>
      .
      .
      .
      <exprM>)
    

    =>

    ((letrec
      ((<name> 
        (lambda (<var1>...<varN>)
          <expr1>
          .
          .
          .
          <exprM>)))
        <name>) <val1>...<valN>)
    

    It can be used as follows: >(let loop ((x 4) (acc 1)) (if (= x 1) acc (loop (- x 1) (* x acc)))) 24 > Use define-macro to define named-let.

  • The special form, while, is a control structure common to many programming languages. In while, an expression is evaluated repeatedly as long as a given condition is true. We can effect the behavior of a while expression as illsutrated by the following program, which sums the numbers from 1 to 100: (let ((n 100) (sum 0)) (letrec ((loop (lambda () (if (positive? n) (begin (set! sum (+ sum n)) (set! n (sub1 n)) (loop)))))) (loop) sum)) We would like to introduce the special form, while, which allows us to write the above program as: (let ((n 100) (sum 0)) (while (positive? n) (set! sum (+ sum n)) (set! n (sub1 n))) sum) While has the following abstract syntax:

    (while <test> <expr1>...<exprN>)
    

    =>

    (letrec
      ((loop
        (lambda ()
          (if <test>
            (begin
              <expr1>
    	  .
    	  .
    	  .
    	  exprN>)))))
      (loop))
    

    Define while using define-macro. You must take into account the potential variable capturing that is caused when the variable loop occurs free in test or expression.