(require-library typed-lists cells simple-tests)
(import typed-lists simple-tests cells)

(define-test (number-lists?)
  (check
    (define-list-type nlist
                      documentation: nlists
                      item-predicate: (lambda (x)
                                        (or (number? x)
                                            ((cell-of? number?) x)))
                      item-equality: (lambda (x y)
                                       (or (and (number? x)
                                                (number? y)
                                                (= x y))
                                           (and (cell? x)
                                                (cell? y)
                                                (= (cell-ref x)
                                                   (cell-ref y))))))

    (define nnil (nnull))
    (nlist? nnil)
    (nnull? nnil)
    (not (null? nnil))
    (define nls (ncons 1 nnil))
    (nlist? nls)
    nls
    (define nlst (nlist 0 1 (cell 2) 3 4))
    (nlist? nlst)
    (not (list? nlst))
    nlst
    (= (napply + 1 2 (nlist 3 4 5)) 15)
    (nequal? (nrepeat 5 0) (nlist 0 0 0 0 0))
    (nequal? (niterate-times 5 add1 0) (nlist 0 1 2 3 4))
    (nequal? (niterate-while (lambda (x) (< x 5)) add1 0)
             (nlist 0 1 2 3 4))
    (nequal? (niterate-until (lambda (x) (= x 5)) add1 0)
             (nlist 0 1 2 3 4))
    (nequal? (nzip (nlist 1 2 3 4 5) (nlist 10 20 30))
             (nlist 1 10 2 20 3 30 4 5))
    (nequal? (ninterpose 10 (nlist 1 2 3 4 5))
             (nlist 1 10 2 10 3 10 4 10 5))
    (nequal? (ncdddr nlst) (nlist 3 4))
    (= (ncadddr nlst) 3)
    (nequal? (ndrop 3 nlst) (nlist 3 4))
    (nequal? (ndrop-while odd? (nlist 1 3 2 4 5))
             (nlist 2 4 5))
    (nequal? (ntake-while odd? (nlist 1 3 2 4 5))
             (nlist 1 3))
    (receive (head tail) (nsplit-with even? (nlist 1 3 2 4 5))
      (and (nequal? head (nlist 1 3))
           (nequal? tail (nlist 2 4 5))))
    (nequal? (ntake 2 nlst) (nlist 0 1))
    (define nrest (ncdr nlst))
    nrest
    (nlist? (nnull))
    (nnull? (nnull))
    (not (nnull? nls))
    (not (nlist? '(1 2)))
    (nnull? (ncdr nls))
    (= (ncar nlst) 0)
    (nlist? (nreverse nlst))
    (nreverse nlst)
    (equal? (nlist->list nlst)
            (list 0 1 (cell 2) 3 4))
    (equal? (nref 2 nlst) (cell 2))
    (cell-set! (nref 2 nlst) 20)
    (equal? (nref 2 nlst) (cell 20))
    (= (cell-ref (nref 2 nlst)) 20)
    (= (nlength nlst) 5)
    (nequal? (nsublist 2 4 nlst)
             (nlist (cell 20) 3))
    (nequal?  (nappend (nlist 0 1 2 3)
                       (nlist 4 5 6))
              (nlist 0 1 2 3 4 5 6))
    (nequal? (nappend (nlist 0)
                      (nlist 1)
                      (nlist 2)
                      (nlist 3 4)
                      (nlist 5 6 7)
                      (nlist 8))
             (nlist 0 1 2 3 4 5 6 7 8))
    (nequal? (nmap add1
                   (nlist 0 1 2 3))
             (nlist 1 2 3 4))
    (nequal? (nmap +
                   (nlist 1 2 3)
                   (nlist 10 20 30 40))
             (nlist 11 22 33))
    (nequal?
      (nmappend nlist (nlist 10 20 30) (nlist 1 2 3 4 5))
      (nlist 10 1 20 2 30 3))
    (nequal?
      (nfold-right ncons (nnull) (nlist 0 1 2 3 4))
      (nlist 0 1 2 3 4))
    (nequal? (nfold-right ncons (nnull) (nlist 0 1 2 3 4))
             (nlist 0 1 2 3 4))
    (= (nfold-left + 0 (nlist 1 2 3) (nlist 10 20 30)) 66)
    (equal? (nfold-left cons '(100) (nlist 1 2 3 4))
            '(((((100) . 1) . 2) . 3) . 4))
    (equal?
      (call-with-values
        (lambda () (nreverse* (nlist 1 2 3) (nlist 10 20 30)))
        list)
      (list (nlist 3 2 1) (nlist 30 20 10)))
    (nequal? (nremove 0 (nlist 1 0 2 0 3 0 4))
             (nlist 1 2 3 4))
    (nequal? (nmerge < (nlist 2 4 5 7 8) (nlist 1 3 6 9 10))
             (nlist 1 2 3 4 5 6 7 8 9 10))
    (not (condition-case (nmerge < (nnull) (nlist 1 3 2))
           ((exn) #f)))
    (nequal? (nsort <= (nlist 2 0 1 4 3))
             (nlist 0 1 2 3 4))
    (not (nsorted? <= (nlist 2 0 1 4 3)))
    (nsorted? <= (nlist 0 1 2 3 4))
    (nevery? odd? (nlist 1 3 5))
    (nevery? odd? (nlist))
    (= (nsome odd? (nlist 2 3 5)) 3)
    (not (nsome odd? (nlist 2 4 6)))
    (nnot-every? odd? (nlist 1 2 3))
    (nnot-any? odd? (nlist 2 4 6))
    ;;; sets
    (nset-equal?
      (nlist->set (nlist 1 2 1 3 2 3))
      (nset 3 2 1))
    (nset? (nset 1 2 3))
    (nset? (nset 1 2 2 3))
    (nset-equal? (nset 2 1 3) (nset 1 2 2 3))
    (nset-in? 2 (nset 1 1 2 3))
    (nsubset? (nset 2 1 2) (nset 4 1 2 3 4))
    (nset-equal?
      (nset-add 0 (nset 1 2 3))
      (nset 0 1 2 3))
    (nset-equal?
      (nset-add 2 (nset 1 2 3))
      (nset 1 2 3))
    (nset-equal?
      (nset 0 1 1 0 2 3 2)
      (nset 2 3 0 1))
    (nset-equal?
      (nset-difference (nset 0 2 1 3) (nset 1 1))
      (nset 0 2 3))
    (nset-equal?
      (nset-union (nset 1 2) (nset 2 3) (nset 3 4))
      (nset 1 2 3 4))
    (nset-equal?
      (nset-intersection (nset 1 2 3 4) (nset 2 3 5) (nset 3 4))
      (nset 3))
    (nset-equal? (nsubset odd? (nset 2 1 3 3 1 1)) (nset 3 1))
    ))

(define-test (strlists?)
  (check
    (define-list-type strlist
                      documentation: strlists
                      item-predicate: string?
                      item-equality: string=?)
    (strequal?
      (strappend (strlist "a" "b")
                 (strlist "c"))
      (strlist "a" "b" "c"))
    ))

(define-test (symlists?)
  (check
    (define-list-type symlist
                      documentation: symlists
                      item-predicate: symbol?
                      item-equality: eq?)
    (symequal?
      (symappend (symlist 'a 'b)
                 (symlist 'c))
      (symlist 'a 'b 'c))
    ))

(define-test (llists?)
  (check
    (define-list-type llist
                      documentation: llists
                      item-predicate: list?
                      item-equality: equal?)
    (lequal?
      (lappend (llist '(a) '(b))
               (llist '(c)))
      (llist '(a) '(b) '(c)))
    ))

(define-test (alists?)
  (check
    (define-list-type alist
                      documentation: alists
                      item-predicate: (lambda (x) #t)
                      item-equality: equal?)
    (define als (make-alist 3 (cell #f)))
    (alist? als)
    (not (list? als))
    (= (alength als) 3)
    (equal? (alist->list (amap cell-ref als)) (make-list 3))
    (define alst (alist (lambda (x) #f) 'a "x" (cell 3) #\z))
    (procedure? (acar alst))
    (aequal? (amemp cell? alst)
                  (alist (cell 3) #\z))
    (aequal? (amember #\z alst)
             (acons #\z (anull)))
    ))

(define-test (plists?)
  (check
    (define-list-type nsplist
                      documentation: plists
                      item-predicate: (lambda (pair)
                                        (and (pair? pair)
                                             (number? (car pair))
                                             (string? (cdr pair))))
                      item-equality: equal?
                      procedure-prefix: nsp)
    (define nspl (nsplist (cons 1 "one") (cons 2 "two") (cons 3 "three")))
    (equal? (nspassoc 2 nspl) '(2 . "two"))
    (not (nspassp zero? nspl))
    ))


(compound-test (TYPED-LISTS)
  (number-lists?)
  (strlists?)
  (symlists?)
  (llists?)
  (alists?)
  (plists?)
  )