(define head
  (lambda (sequence) 
    (sequence 'head)))

(define tail
  (lambda (sequence)
    (sequence 'tail)))

(define empty-sequence?
  (lambda (sequence)
    (sequence 'empty-sequence?)))

(define sequence-length
  (lambda (sequence)
    (sequence 'sequence-length)))

(define sequence-from-to
  (lambda (low high)
    (lambda (op)
      (cond ((equal? op 'empty-sequence?)
             (> low high))
            ((equal? op 'head)
             low)
            ((equal? op 'tail)
             (sequence-from-to (+ low 1)  high))
            ((equal? op 'sequence-length)
             (if (> low high) 0 (+ (- high low) 1)))
            ((equal? op 'sequence-ref)
             (lambda (n)
               (if (and (<= 0 n) (<= n (- high low)))
                   (+ low n)
                   (error "sequence-from-to: index out of range"
                          n))))
            (else (error "illegal sequence operation" op))))))

(define sequence-ref
  (lambda (sequence n)
    ((sequence 'sequence-ref) n)))

(define sequence-cons
  (lambda (head tail)
    (let ((new-length (+ 1 (sequence-length tail))))
      (lambda (op)
        (cond ((equal? op 'empty-sequence?)
               #f)
              ((equal? op 'head)
               head)
              ((equal? op 'tail)
               tail)
              ((equal? op 'sequence-length)
               new-length)
              ((equal? op 'sequence-ref)
               (lambda (n)
                 (if (= n 0)
                     head
                     (sequence-ref tail (- n 1)))))
              (else (error "illegal sequence operation" op)))))))

(define sequence-append
  (lambda (seq-1 seq-2)
    (cond ((empty-sequence? seq-1) seq-2)
          ((empty-sequence? seq-2) seq-1)
          (else
           (let ((seq-1-length (sequence-length seq-1))
                 (seq-2-length (sequence-length seq-2)))
             (lambda (op)
               (cond ((equal? op 'empty-sequence?)
                      #f)
                     ((equal? op 'head)
                      (head seq-1))
                     ((equal? op 'tail)
                      (sequence-append (tail seq-1) seq-2))
                     ((equal? op 'sequence-length)
                      (+ seq-1-length seq-2-length))
                     ((equal? op 'sequence-ref)
                      (lambda (n)
                        (cond ((< n seq-1-length)
                               (sequence-ref seq-1 n))
                              (else
                               (sequence-ref seq-2
                                             (- n seq-1-length))))))
                     (else (error "illegal sequence operation"
                                  op)))))))))


(define list->sequence
  (lambda (lst)
    (lambda (op)
      (cond ((equal? op 'empty-sequence?)
             (null? lst))
            ((equal? op 'head)
             (car lst))
            ((equal? op 'tail)
             (list->sequence (cdr lst)))
            ((equal? op 'sequence-length)
             (length lst))
            ((equal? op 'sequence-ref)
             (error "we didn't get around to writing this"))
            (else (error "illegal sequence operation" op))))))

(define sequence-sums
  (lambda (seq)
    (sequence-sums-with-prior-total seq 0)))

(define sequence-sums-with-prior-total
  (lambda (seq total)
    (if (empty-sequence? seq)
        seq
        (let ((first (+ total (head seq))))
          (sequence-cons first
                         (sequence-sums-with-prior-total (tail seq)
                                                         first))))))