(r5rs.info.gz) Iteration

(r5rs.info.gz) Derived expression types
 
 4.2.4 Iteration
 ---------------
 
 
 
  -- library syntax: do ((<variable1> <init1> <step1>) ...) (<test>
           <expression> ...) <command> ...
      `Do' is an iteration construct.  It specifies a set of variables to
      be bound, how they are to be initialized at the start, and how
      they are to be updated on each iteration.  When a termination
      condition is met, the loop exits after evaluating the
      <expression>s.
 
      `Do' expressions are evaluated as follows: The <init> expressions
      are evaluated (in some unspecified order), the <variable>s are
      bound to fresh locations, the results of the <init> expressions
      are stored in the bindings of the <variable>s, and then the
      iteration phase begins.
 
      Each iteration begins by evaluating <test>; if the result is false
      (see section  Booleans), then the <command> expressions are
      evaluated in order for effect, the <step> expressions are
      evaluated in some unspecified order, the <variable>s are bound to
      fresh locations, the results of the <step>s are stored in the
      bindings of the <variable>s, and the next iteration begins.
 
      If <test> evaluates to a true value, then the <expression>s are
      evaluated from left to right and the value(s) of the last
      <expression> is(are) returned.  If no <expression>s are present,
      then the value of the `do' expression is unspecified.
 
      The region of the binding of a <variable> consists of the entire
      `do' expression except for the <init>s.  It is an error for a
      <variable> to appear more than once in the list of `do' variables.
 
      A <step> may be omitted, in which case the effect is the same as
      if `(<variable> <init> <variable>)' had been written instead of
      `(<variable> <init>)'.
 
      (do ((vec (make-vector 5))
           (i 0 (+ i 1)))
          ((= i 5) vec)
        (vector-set! vec i i))               ==>  #(0 1 2 3 4)
 
      (let ((x '(1 3 5 7 9)))
        (do ((x x (cdr x))
             (sum 0 (+ sum (car x))))
            ((null? x) sum)))                ==>  25
 
 
  -- library syntax: let <variable> <bindings> <body>
      "Named `let'" is a variant on the syntax of `let' which provides a
      more general looping construct than `do' and may also be used to
      express recursions.  It has the same syntax and semantics as
      ordinary `let' except that <variable> is bound within <body> to a
      procedure whose formal arguments are the bound variables and whose
      body is <body>.  Thus the execution of <body> may be repeated by
      invoking the procedure named by <variable>.
 
      (let loop ((numbers '(3 -2 1 6 -5))
                 (nonneg '())
                 (neg '()))
        (cond ((null? numbers) (list nonneg neg))
              ((>= (car numbers) 0)
               (loop (cdr numbers)
                     (cons (car numbers) nonneg)
                     neg))
              ((< (car numbers) 0)
               (loop (cdr numbers)
                     nonneg
                     (cons (car numbers) neg)))))
                ==>  ((6 1 3) (-5 -2))
Info Catalog
(r5rs.info.gz) Sequencing
(r5rs.info.gz) Derived expression types
(r5rs.info.gz) Delayed evaluation
automatically generated byinfo2html