sicp-ex-4.1

meteorgan

  
  
 ;; left to righ 
 (define (list-of-values1 exps env) 
   (if (no-operand? exps) 
       '() 
       (let* ((left (eval (first-operand exps) env)) 
                 (right (eval (rest-operands exps) env))) 
         (cons left right)))) 
  
 ;; right to left 
 (define (list-of-values2 exps env) 
   (if (no-operand? exps) 
       '() 
       (let* ((right (eval (rest-operands exps) env)) 
                 (left (eval (first-operand exps) env))) 
         (cons left right))))

craig

99% certain meteorgan's code should have the words "left" and "right" swapped in the let* in list-of-values2 (the right to left version). Only 99%, so I won't presume to edit it myself.

mathieubordere

  
  
  
 ;;; left-to-right 
 (define (list-of-values-l2r exps env) 
   (if (no-operands? exps) 
       '() 
       (let ((first-exp (eval (first-operand exps) env))) 
         (cons first-exp 
               (list-of-values-l2r (rest-operands exps) env))))) 
  
 ;;; right-to-left 
 (define (list-of-values-r2l exps env) 
   (list-of-values-l2r (reverse exps) env))

Sphinxsky

  
  
  
 ; left-to-right 
 (define (list-of-values exps env) 
     (let ((first '()) 
           (rest '())) 
         (if (no-operands? exps) 
             rest 
             (begin 
                 (set! first (eval (first-operand exps) env)) 
                 (set! rest (list-of-values (rest-operands exps) env)) 
                 (cons first rest))))) 
  
 ; right-to-left 
 (define (list-of-values exps env) 
     (let ((first '()) 
           (rest '())) 
         (if (no-operands? exps) 
             rest 
             (begin                 
                 (set! rest (list-of-values (rest-operands exps) env)) 
                 (set! first (eval (first-operand exps) env)) 
                 (cons first rest)))))

I think it's wrong to use cons in right to left.

 ;; ex 4.1 
 ;; left to right 
 (define (list-of-values-l2r exps env) 
  (if (no-operands? exps) 
   '() 
   (let ((v (eval (first-operand exps) env))) 
    (cons v (list-of-values-l2r (cdr exps) env))))) 
  
 ;; right to left 
 (define (list-of-values-r2l exps env) 
  (reverse (list-of-values-l2r (reverse exps) env)))

master

Why? Only the order of evaluation matters. Once the expressions have been evaluated, it literally doesn't matter in what order cons evaluates its arguments because they have already been evaluated and thus evaluating from left-to-right and right-to-left are equivalent. Right?

krubar

  
  
 ;; left-to-right 
 (define (list-of-values exps env) 
   (if (no-operands? exps) 
       '() 
       (let ((first (eval (first-operand exps) env))) 
         (cons first 
               (list-of-values 
                (rest-operands exps) 
                env))))) 
  
 ;; right-to-left 
 (define (list-of-values exps env) 
   (if (no-operands? exps) 
       '() 
       (let ((rest (list-of-values 
                    (rest-operands exps) 
                    env))) 
         (cons (eval (first-operand exps) env) 
               rest))))