(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-ref
  (lambda (sequence n)
    ((sequence 'sequence-ref) n)))

(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))))))))

(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)
             (lambda (n)
               (list-ref lst n)))
            (else (error "illegal sequence operation" op))))))