(require-library simple-tests lazy-lists) 
(import lazy-lists simple-tests)
(register-feature! 'assumptions-checked)

(define-test (lazy-list)
  (check
    (define (First-five) (List 0 1 2 3 4))
    (define (Fibs)
      (Append (List 0 1) (Lazy #f (Map + (Rest (Fibs)) (Fibs)))))
    "PREDICATES"
    (List? (First-five))
    (List-finite? (First-five))
    (List-not-null? (First-five))
    (not (List-not-null? Nil))
    (not (List-finite? (Cardinals)))
    (List? (Cardinals))
    (= (Length-min (First-five) (Cardinals)) 5)
    (Lists-one-finite? (First-five) (Cardinals))
    (Lists-one-finite? (Take 5 (Cardinals)))
    (Lists-one-finite? (List 1 2 3 4))
    (not (Lists-one-finite? (Fibs) (Cardinals)))
    (= (Length (First-five)) 5)
    (= (Length (Rest (First-five))) 4)
    (not (Length (Rest (Cardinals))))
    (= (Length (Take 5 (Cardinals))) 5)
    (not (Length (Cardinals)))
    (not (Length (Drop 5 (Cardinals))))
    (= (First (Drop 5 (Cardinals))) 5)
    (Eqv? (First-five) (List 0 1 2 3 4))
    (Eqv? (Take 5 (Cardinals)) (List 0 1 2 3 4))
    (= (Length (Range 2 10)) (- 10 2))
    (= (Length (Range 10)) 10)
    (= (Length (Range -1 10 2)) 6)
    (Eqv? (Range -1 10 2) (List -1 1 3 5 7 9))
    (Eqv? (Range 2 10) (List 2 3 4 5 6 7 8 9))
    (Eqv? (Range 10 2) (List 10 9 8 7 6 5 4 3))
    (Eqv? (Drop-while (cut < <> 3) (First-five))
          (List 3 4))
    (Eqv? (Take-while (cut < <> 3) (First-five))
          (List 0 1 2))
    (equal?
      (receive (head index tail) (Split-with (cut < <> 3) (First-five))
        (cons (First tail) (List->list head)))
      '(3 0 1 2))
    (equal?
      (receive (head index tail) (Split-with (cut < <> 5) (Take 10 (Cardinals)))
        (append (List->list tail) (List->list head)))
      '(5 6 7 8 9 0 1 2 3 4))
    (= (Count-while (cut < <> 2) (First-five)) 2)
    (= (Count-while (cut < <> 20) (First-five)) 5)
    (Eqv? (Take-while (cut < <> 5) (Take 10 (Cardinals)))
          (List 0 1 2 3 4))
    (= (Length (Take-while (cut < <> 5) (Take 10 (Cardinals)))) 5)
    (= (Length (Drop-while (cut < <> 5) (Take 10 (Cardinals)))) 5)
    (= (First (Drop-while (cut < <> 5) (Take 10 (Cardinals)))) 5)
    (= (Length (Drop-while (cut < <> 2) (First-five))) 3)
    (= (First (Drop-while (cut < <> 2) (First-five))) 2)
    (Eqv? (Memp odd? (First-five)) (List 1 2 3 4))
    (Eqv? (Memv 5 (Take 10 (Cardinals))) (List 5 6 7 8 9))
    (equal? (Assv 5 (Take 10 (Map (lambda (x) (list x x)) (Cardinals))))
            '(5 5))
    (not (Assv 10 (Map (lambda (x) (list x x)) (First-five))))
    (not (Equal? (Cardinals) (Cardinals)))
    (let ((Card (Cardinals)))
      (Equal? Card Card))
    (not (Equal? (Cardinals) (First-five)))
    (Equal? (First-five) (First-five))
    (= (Length (Take 10 (Cardinals))) 10)
    (Eqv? (Take 5 (Filter odd? (Drop 1 (Cardinals))))
          (List 1 3 5 7 9))
    (Eqv? (Remp odd? (First-five)) (List 0 2 4))
    (Eqv? (Take 5 (Remp odd? (Cardinals)))
          (Take 5 (Map (cut * <> 2) (Cardinals))))
    (Eqv? (Remv 3 (First-five)) (List 0 1 2 4))
    (not (Length (Cardinals)))
    (Eqv? (Map add1 (First-five)) (List 1 2 3 4 5))
    (Eqv? (Map + (First-five) (Take 5 (Cardinals)))
          (List 0 2 4 6 8))
    (not (Length (Map + (Cardinals) (Cardinals))))
    (For-each (lambda (x y) (print "### " x " " y)) (Cardinals) (First-five))
    (= (Length (Filter odd? (First-five))) 2)
    (Eqv? (Filter odd? (First-five)) (List 1 3))
    (not (Length (Filter odd? (Cardinals))))
    (Eqv? (Take 10 (Zip (First-five) (Cardinals)))
          (List 0 0 1 1 2 2 3 3 4 4))
    (not (Length (Zip (First-five) (Cardinals))))
    (= (At 20 (Sieve = (Zip (Cardinals) (Cardinals)))) 20)
    (Eqv? (Sieve = (Zip (First-five) (First-five)))
          (List 0 1 2 3 4))
    (= (At 25 (Cardinals)) 25)
    (= (At 2 (First-five)) 2)
    (Eq? (Repeat #f 3) (List #f #f #f))
    (List-infinite? (Repeatedly (lambda () 1)))
    (Eqv? (Repeatedly (lambda () 1) 3)
          (List 1 1 1))
    (List-infinite? (Iterate add1 0))
    (List-finite? (Iterate add1 0 3))
    (Eqv? (Iterate add1 0 3) (List 0 1 2))
    (not (Length (Iterate add1 0)))
    (Eqv? (Cycle 10 (First-five))
          (List 0 1 2 3 4 0 1 2 3 4))
    (not (Length (Cycle (First-five))))
    (= (Length (Append (First-five) (First-five))) 10)
    (not (Length (Append (Cardinals) (First-five))))
    (Eqv? (Append (First-five) (First-five))
          (List 0 1 2 3 4 0 1 2 3 4))
    (Eqv? (Take 12 (Append (First-five) (Cardinals)))
          (List 0 1 2 3 4 0 1 2 3 4 5 6))
    (not (Length (Append (First-five) (Cardinals))))
    (List-finite? (Reverse (First-five)))
    (List-finite? Nil)
    (zero? (Length Nil))
    (Equ? = (Reverse (First-five)) (List 4 3 2 1 0))
    (Equ? = (Reverse (Take 5 (Cardinals))) (List 4 3 2 1 0))
    (= (Length (List 0 1 2 3 4)) 5)
    (= (Length (Reverse (First-five))) 5)
    (not (Length (Reverse* (Cardinals))))
    (Equal? (At 5 (Reverse* (Cardinals))) (List 5 4 3 2 1 0))
    (Equal? (At 4 (Reverse* (First-five))) (List 4 3 2 1 0))
    (Sorted? < (First-five))
    (not (Sorted? < (Append (First-five) (First-five))))
    (Equal? (Sort < (First-five)) (List 0 1 2 3 4))
    (= (Length (Sort < (First-five))) 5)
    (Equal? (Sort < (List 3 1 0 2 4)) (List 0 1 2 3 4))
    (equal?
      (receive (head tail) (Split-at 5 (Cardinals))
        (cons (First tail) (List->list head)))
      '(5 0 1 2 3 4))
    "FOLDS"
    (define (cons-right var lst)
      (if (null? lst)
        (cons var lst)
        (cons (car lst) (cons-right var (cdr lst)))))
    (equal? (cons-right 10 '(0 1 2 3)) '(0 1 2 3 10))
    (= (Fold-left + 0 (Take 5 (Cardinals))) 10)
    (= (Fold-left + 0 (First-five) (First-five)) 20)
    (= (Fold-left * 1 (List 1 2 3 4)) 24)
    (equal? (Fold-left cons '() (Take 5 (Cardinals)))
            '(((((() . 0) . 1) . 2) . 3) . 4))
    (equal? (At 4 (Fold-left* cons '() (Cardinals)))
            '(((((() . 0) . 1) . 2) . 3) . 4))
    (= (Fold-right + 0 (Take 5 (Cardinals))) 10)
    (= (Fold-right + 0 (First-five) (First-five)) 20)
    (equal? (Fold-right cons '() (First-five))
            '(0 1 2 3 4))
    (equal? (Fold-right cons '(a b c) (First-five))
            '(0 1 2 3 4 a b c)) ; append
    (equal? (At 4 (Fold-right* cons '() (Cardinals)))
            '(4 3 2 1 0)) ; note changed order
    (equal? (At 4 (Fold-right* cons-right '() (Cardinals)))
            '(0 1 2 3 4))
    (equal? (At 4 (Fold-right* cons '(a b c) (Cardinals)))
            '(4 3 2 1 0 a b c)) ; note changed order
    (equal? (At 4 (Fold-right* cons-right '(a b c) (Cardinals)))
            '(a b c 0 1 2 3 4))
    "TRANSFORMATIONS"
    (Equal? (vector->List #(0 1 2 3 4)) (List 0 1 2 3 4))
    (Null? (vector->List #()))
    (equal? (List->vector (Take 5 (Cardinals))) #(0 1 2 3 4))
    (equal? (List->vector (First-five)) #(0 1 2 3 4))
    (equal? (List->vector Nil) '#())
    (Every? odd? (Take 15 (Filter odd? (Cardinals))))
    (not (Every? odd? (Take 15 (Cardinals))))
    (Every? odd? Nil)
    (not (Some? odd? Nil))
    (not (Some? odd? (Take 5 (Filter even? (Cardinals)))))
    (Some? odd? (First-five))
    "ZIP AND UNZIP"
    (not (Length (Zip (Cardinals) (First-five))))
    (not (Length (Zip (First-five) (Cardinals))))
    (not (Length (Zip (Cardinals) (Cardinals))))
    (= (Length (Zip (First-five) (First-five))) 10)
    (Eqv? (Take 14 (Zip (Cardinals) (First-five)))
          (List 0 0 1 1 2 2 3 3 4 4 5 6 7 8))
    (Eqv? (Take 14 (Zip (Cardinals) (Cardinals)))
          (List 0 0 1 1 2 2 3 3 4 4 5 5 6 6))
    (Eqv? (Zip (First-five) (First-five))
          (List 0 0 1 1 2 2 3 3 4 4))
    (receive (Evens Odds) (Unzip (Cardinals))
      (and (Eqv? (Take 5 Evens) (List 0 2 4 6 8))
           (Eqv? (Take 5 Odds) (List 1 3 5 7 9))))
    "PRIMES AND FIBS"
    (= (At 50 (Primes)) 233)
    (Eqv? (Take 5 (Primes)) (List 2 3 5 7 11))
    (Eqv? (Take 10 (Fibs)) (List  0 1 1 2 3 5 8 13 21 34))
    "LIST OF SUMS"
    (define (Sums Lst)
      (let loop ((n 1))
        (Lazy #f (cons (apply + (List->list (Take n Lst)))
                       (loop (fx+ n 1))))))
    (Eqv? (Take 5 (Sums (Cardinals))) (List 0 1 3 6 10))
    "COMPUTE SQUARE ROOT BY NEWTON'S METHOD"
    (define (Within eps Lst)
      (let loop ((Lst Lst))
        (let ((a (At 0 Lst)) (b (At 1 Lst)))
          (if (< (abs (- a b)) eps)
            b
            (loop (Rest Lst))))))
    (define (Relative eps Lst)
      (let loop ((Lst Lst))
        (let ((a (At 0 Lst)) (b (At 1 Lst)))
          (if (<= (abs (/ a b)) (* (abs b) eps))
            b
            (loop (Rest Lst))))))
    (define (Newton x) ; fixed point for square root
      (lambda (a) (/ (+ a (/ x a)) 2))) 
    (let ((eps 0.000001))
      (< (abs (- (sqrt 2) (Within eps (Iterate (Newton 2) 2)))) eps))
    "IF NOT A THUNK A USE OF A LIST IMPLIES REALIZING"
    (define Integers
      (let loop ((n 1)) (Lazy #f (cons n (loop (+ n 1))))))
    (List? Integers)
    (not (List-finite? Integers))
    (not (Realized? Integers))
    (= (At 5 Integers) 6)
    (Realized? Integers)
    ))
(compound-test (LAZY-LISTS)
  (lazy-list)
  )