(use simple-tests list-comprehensions)

(define-test (lists?)
  (check
    (equal? (range 0) '())
    (equal? (range 5) '(0 1 2 3 4))
    (equal? (range -5) '(0 -1 -2 -3 -4))
    (equal? (range 1 5) '(1 2 3 4))
    (equal? (range 5 1) '(5 4 3 2))
    (equal? (range 1 5 2) '(1 3))
    (equal? ((repeat 5) 'x) '(x x x x x))
    (equal? ((iterate-times add1 5) 1) '(1 2 3 4 5))
    (equal? ((iterate-until sub1 zero?) 5) '(5 4 3 2 1))
    (equal? ((iterate-while sub1 positive?) 5) '(5 4 3 2 1))
    (equal? (for ((x 1 (add1 x) (>= x 10) (odd? x))) x)
            '(1 3 5 7 9))
    (equal? (for ((x 1 (add1 x) (>= x 10) (odd? x))
                  (y 2 (add1 y) #t (even? y)))
              (cons x y))
            '((1 . 2) (3 . 4) (5 . 6) (7 . 8) (9 . 10)))
    (equal? (for* ((x 1 (add1 x) (>= x 8) (odd? x))
                   (y 2 (add1 y) (>= y x) (even? y)))
              (cons x y))
            '((3 . 2) (5 . 2) (5 . 4) (7 . 2) (7 . 4) (7 . 6)))
    (equal? (for ((x 0 (add1 x) #t (odd? x))
                  (y 1 (add1 y) (>= y 8) (even? y)))
              (let ((a (* x x)) (b (+ y y)))
                (list (cons x a) (cons y b))))
            '(((1 . 1) (2 . 4))
              ((3 . 9) (4 . 8))
              ((5 . 25) (6 . 12))))
    (equal? (for ((x (range 10) (cdr x) (null? x) (or (null? x) (odd? (car x)))))
              (car x))
            '(1 3 5 7 9))
    (equal? (let* ((lst (range 1 7))
                   (len (length lst)))
              (for ((k 0 (add1 k) (>= k len) (even? k)))
                (let ((val (list-ref lst k)))
                  (* 2 val))))
            '(2 6 10))
    (equal? (let* ((vec (vector 0 1 2 3 4 5 6))
                   (len (vector-length vec)))
              (for ((k 0 (add1 k) (>= k len) (even? k)))
                (let ((val (vector-ref vec k)))
                  (* val val))))
            '(0 4 16 36))
    ))
(compound-test (LIST-COMPREHENSIONS)
  (lists?)
  )