;;; First version of compose to write on the board:

(define compose
  (lambda fn-list
    (lambda (x)
      (if (null? fn-list)
          x
          ((car fn-list)
           ((apply compose (cdr fn-list))
	    x))))))

; 2- or 3-arg version with case-lambda

(define compose  ; two or three arg version
  (case-lambda   ;     of compose from A6.
   [(f g) (lambda (x) (f (g x)))]
   [(f g h) (lambda (x) (f (g (h x))))]))

;  Full compose with case-lambda

(define compose
  (case-lambda
    [() (lambda (x) x)]
    [(first . rest)
     (lambda (x)
       (first ((apply compose rest) x)))]))

; compose with case-lambda alternate version
; better?

(define compose
  (case-lambda
    [() (lambda (x) x)]
    [(first . rest)
     (let ([composed-fns (apply compose rest)])
	     (lambda (x)
	       (first (composed-fns x))))]))

(define rotate   ; rotate the last list  
                 ; element to the beginning
  (lambda (los)
    (let loop ([los los]
               [sofar '()])
      (cond 
       [(null? los) los]
       [(null? (cdr los)) 
	(cons (car los) sofar)]
       [else 
	(loop (cdr los)
	      (append sofar 
		      (list (car los))))]))))

(define rotate-linear 
	   ;build up the list in reverse
	   ; order, then reverse it.
  (lambda (los)
    (let loop ([los los]
	       [sofar '()])
      (cond [(null? los) los]
	    [(null? (cdr los)) 
	     (cons (car los) 
		   (reverse sofar))]
	    [else              
             (loop (cdr los)
                   (cons (car los) sofar))]))))



(define make-long-list ; make a list of n different numbers.
  (lambda (n) 
    (if (zero? n)
	'()
	(cons n (make-long-list (- n 1))))))

(define long (make-long-list 30000))

(begin
  (collect)(time (rotate-linear long))
  (collect) (time (rotate long))
  'done)