;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Interface for Sequence
;;
;;
;(head sequence)
  ; returns the first element of sequence, provided sequence is
  ; nonempty

;(tail sequence)
  ; returns all but the first element of sequence as a
  ; sequence, provided sequence is nonempty

;(empty-sequence? sequence)
  ; returns true if and only if sequence is empty

;(sequence-length sequence)
  ; returns the length of sequence

;(sequence-ref sequence n)
  ; returns the nth element of sequence, counting from 0

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; sequence-from-to constructor
;;
;;
(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)
              (cond ((< n 0) (error "jkljkljl"))
                    ((> n (- high low)) (error "qweqweqwe"))
                    (else
                     (+ low n)))))
            (else (error "illegal sequence operation" op))))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Wrappers for message-passing interface
;;
;;
(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)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; list->sequence constructor
;;
;;
(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))))))

(define sequence->list
  (lambda (sequence)
    (if (empty-sequence? sequence)
        '()
        (cons (head sequence)
              (sequence->list (tail sequence))))))

(define integers-from-to
  (lambda (low high)
    (sequence->list (sequence-from-to low high))))

(define sequence-cons
  (lambda (element sequence)
    (lambda (op)
      (cond ((equal? op 'empty-sequence?)
             #f)
            ((equal? op 'head)
             element)
            ((equal? op 'tail)
             sequence)
            ((equal? op 'sequence-length)
             (+ 1 (sequence-length sequence)))
            (else (error "illegal sequence operation" op))))))