;; These four procedures come from the book
(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)))

;; The rest is ours

(define reverse
  (lambda (sequence)
    (sequence 'reverse)))

(define make-empty-sequence
  (lambda ()
    (define f
      (lambda (op)
        (cond ((equal? op 'empty-sequence?) #t)
              ((or (equal? op 'head) (equal? op 'tail))
               (error "illegal operation on an empty sequence" op))
              ((equal? op 'sequence-length) 0)
              ((equal? op 'reverse) f)
              (else (error "illegal sequence operation" op)))))
    f))

(define sequence-from-to
  (lambda (start end)
    (lambda (op)
      (cond ((equal? op 'empty-sequence?)
             #f)
            ((equal? op 'head)
             start)
            ((equal? op 'tail)
             (cond ((= start end) (make-empty-sequence))
                   ((< start end) (sequence-from-to (+ start 1) end))
                   (else (sequence-from-to (- start 1) end))))
            ((equal? op 'sequence-length)
             ((+ (abs (- end start)) 1)))
            ((equal? op 'reverse)
             (sequence-from-to end start))
            (else (error "illegal sequence operation" op))))))
 
(define sequence->list
  (lambda (seq)
    (if (empty-sequence? seq)
        '()
        (cons (head seq) (sequence->list (tail seq))))))