letrec

(letrec <bindings> <body>)


Description:

Syntax: <Bindings> should have the form


         ((<variable1> <init1>) ...),


and <body> should be a sequence of one or more expressions. It is an

error for a <variable> to appear more than once in the list of

variables being bound.


Semantics: The <variable>s are bound to fresh locations holding

undefined values, the <init>s are evaluated in the resulting

environment (in some unspecified order), each <variable> is assigned to

the result of the corresponding <init>, the <body> is evaluated in the

resulting environment, and the value(s) of the last expression in

<body> is(are) returned.  Each binding of a <variable> has the entire

letrec expression as its region, making it possible to define mutually

recursive procedures.



One restriction on letrec is very important: it must be possible to

evaluate each <init> without assigning or referring to the value of any

<variable>.  If this restriction is violated, then it is an error.  The

restriction is necessary because Scheme passes arguments by value

rather than by name.  In the most common uses of letrec, all the

<init>s are lambda expressions and the restriction is satisfied

automatically.


Arguments:


Returns: boolean


Examples:

(letrec ((even?

         (lambda (n)

            (if (zero? n)

                #t

                (odd? (- n 1)))))

         (odd?

          (lambda (n)

             (if (zero? n)

                 #f

                 (even? (- n 1))))))

         (even? 88))

                       =>  #t



Back to index