(define list-average
  (letrec ([helper (lambda (L)
                     (if (null? L)
                         (list 0 0) ; sum, length
                         (let ([return (helper (cdr L))])
                            (list (+ (car return) (car L))
                                  (+ 1 (cadr return))))))])
    (lambda (L)
      (apply / (helper L)))))
	  

(call-with-values 
  (lambda () (values 3 4)) 
  cons)
  
(call-with-values 
    values 
    (lambda args args))
   
 (call-with-values + list)
 
 (call-with-values list list)


(define split
  (lambda (ls)
    (if (or (null? ls) (null? (cdr ls)))
        (values ls '())
        (call-with-values
          (lambda () (split (cddr ls)))
          (lambda (odds evens)
            (values (cons (car ls) odds)
                    (cons (cadr ls) evens)))))))
					
(split '(a b c d e f))
					
(call-with-values (lambda () (split '(a b c d e f)))  list)

(define list-average
  (letrec ([helper (lambda (L)
                     (if (null? L)
                         (values 0 0) ; sum, length
                         (call-with-values
                             (lambda () (helper (cdr L)))
                             (lambda (sum len)
                               (values (+ sum (car L)) 
							   (+ 1 len))))))])
    (lambda (L)
      (call-with-values (lambda ()(helper L))
                        /))))


(define-syntax with-values
  (syntax-rules ()
    [(_ expr consumer)
     (call-with-values (lambda () expr) 
                        consumer)]))

(with-values (split '(a b c d e f)) list)

(define list-average
  (letrec ([helper 
            (lambda (L)
              (if (null? L)
                  (values 0 0) ; sum, length
                  (with-values
                     (helper (cdr L))
                     (lambda (sum len)
                       (values (+ sum (car L)) 
					   (+ 1 len))))))])
    (lambda (L)
      (with-values (helper L) / ))))


(define-syntax mvlet
  (syntax-rules ()
    ((_ ((x ...) e0) e1 e2 ...)
     (with-values e0
       (lambda (x ...) e1 e2 ...)))))
	   
(define list-average
  (letrec 
    ([helper 
       (lambda (L)
          (if (null? L)
              (values 0 0) ; sum, length
              (mvlet ((sum len) 
                      (helper (cdr L)))
                (values (+ sum (car L)) 
                        (+ 1 len)))))])
    (lambda (L)
      (with-values (helper L) / ))))