stdlib

(defun range (a b)
;; Example:
;; (range 1 4) -> (list 1 2 3)
;; (range 4 1) -> (list 4 3 2)
    (if (eq a b)
        nil
        (if (lt a b)
            (cons a (range (+ a 1) b))
            (cons a (range (+ a (- 1)) b)))))

(defun count (coll)
;; Example: (count (list 1 2))
    (if (null? coll)
        0
        (+ 1 (count (tail coll)))))

(defun matches (f coll)
;; Example: (matches (lambda (x) (eq 2 x)) (list 2 1 2))
    (if (null? coll)
        0
        (if (f (head coll))
            (+ 1 (matches f (tail coll)))
            (matches f (tail coll)))))

(defun at-index (i coll)
;; Example: (at-index 1 (list 'a' 'b' 'c'))
    (if (or (null? coll) (lt i 0))
        nil
        (if (eq i 0)
            (first coll)
            (at-index (+ i (- 1)) (tail coll)))))

(defun map (f coll)
    (if (null? coll)
        nil
        (cons
            (f (first coll))
            (map f (tail coll)))))

(defun filter (f coll)
    (if (null? coll)
        nil
        (if (f (first coll))
            (cons
                (first coll)
                (filter f (tail coll)))
            (filter f (tail coll)))))

(defun for-each (f coll)
    (if (null? coll)
        nil
        (begin
            (f (head coll))
            (for-each f (tail coll)))))

(defun fold-left (f seed coll)
;; Example: (fold-left + 0 (range 1 5))
    (if (null? coll)
        seed
        (fold-left
            f
            (f seed (head coll))
            (tail coll))))

(defun fold-right (f seed coll)
;; Example: (fold-right * 1 (range 1 5))
    (if (null? coll)
        seed
        (f
            (fold-right f seed (tail coll))
            (head coll))))

(defun prepend (x coll)
    (cons x coll))

(defun append (x coll)
;; Example: (append 5 (append 4 (append 3 nil)))
    (if (null? coll)
        (list x)
        (cons
            (head coll)
            (append x (tail coll)))))

(defun zip (xs ys)
;; Example:
;; Balanced: (zip (list 1 2 3) (list 'a' 'b' 'c'))
;; Unbalanced: (zip (list 1 2 3) (list 'a' 'b'))
    (if (or ;; short-circuit if unbalanced
            (null? xs)
            (null? ys))
        nil
        (cons
            (list
                (head xs)
                (head ys))
            (zip (tail xs) (tail ys)))))

(defun take (n coll)
;; Example: (take 2 (list 1 2 3))
    (if (or
            (null? coll)
            (lte n 0))
        nil
        (cons
            (head coll)
            (take (+ n (- 1)) (tail coll)))))

(defun skip (n coll)
;; Example: (skip 2 (list 1 2 3))
    (cond
        ((null? coll) nil)
        ((lte n 0) coll)
        (else
            (skip (+ n (- 1)) (tail coll)))))

(defun reverse (coll)
;; Example: (reverse (list 1 2 3))
    (begin
        (defun iter (acc xs)
            (if (null? xs)
                acc
                (iter
                    (cons (head xs) acc)
                    (tail xs))))
        (iter nil coll)))

(defun any (f coll)
;; Example: (any (lambda (x) (eq x 0)) (list 1 2 0))
    (if (null? coll)
        #f
        (or
            (f (head coll))
            (any f (tail coll)))))

(defun all (f coll)
;; Example: (all (lambda (x) (gte x 0)) (list 1 2 0))
    (if (null? coll)
        #t
        (and
            (f (head coll))
            (all f (tail coll)))))

(defun concat (xs ys)
;; Example: (concat (list 1 2) (list 3 4))
    (if (null? xs)
        ys
        (cons
            (head xs)
            (concat (tail xs) ys))))

(defun group-n (n coll)
;; Example: (group-n 2 (range 1 7))
    (begin
        (defun group (n coll)
            (cond
                ((null? coll) (list nil nil))
                ((lte n 0) (list nil coll))
                (else
                    (begin
                        (define r
                            (group (+ n (- 1)) (tail coll)))
                        (list
                            (cons (head coll) (first r))
                            (second r))))))
        (defun iter (n coll)
            (begin
                (define pair (group n coll))
                (if (null? (second pair))
                    (list (first pair))
                    (cons
                        (first pair)
                        (iter n (second pair))))))
        (if (lte n 0)
            coll ;; just return original
            (iter n coll))))

(defun flat-map (f coll)
;; Example: (flat-map (lambda (x) (if (eq x 2) (list x x) x))  (list 1 2 3))
    (if (null? coll)
        nil
        (begin
            (define r (f (head coll)))
            (if (cell? r)
                (concat r (flat-map f (tail coll)))
                (cons
                    r
                    (flat-map f (tail coll)))))))


(defun flatten (coll)
;; Example: (flatten (list (list (list 1 2) 3) 4 (list 5 (list 6 (list 7)) 8)))
    (if (null? coll)
        nil
        (if (cell? (head coll))
            (concat
                (flatten (head coll))
                (flatten (tail coll)))
            (cons
                (head coll)
                (flatten (tail coll))))))

(defun seed-n (seed n)
;; Example: (seed-n 'a' 10)
    (if (lte n 0)
        nil
        (cons
            seed
            (seed-n seed (+ n (- 1))))))

(defun assoc (coll)
;; Example: (assoc (list 'foo' 'bar' 'baz'))
    (begin
        (defun iter (i xs)
            (if (null? xs)
                nil
                (cons
                    (list i (head xs))
                    (iter (+ 1 i) (tail xs)))))
        (iter 0 coll)))

(defun find-index (f coll)
;; Example: (find-index (lambda (x) (eq x 2)) (list 1 2 3 4))
    (begin
        (defun iter (i f xs)
            (if (null? xs)
                (- 1)
                (if (f (head xs))
                    i
                    (iter (+ 1 i) f (tail xs)))))
        (iter 0 f coll)))

(defun find (f coll)
;; Example: (find (lambda (x) (gt x 2)) (list 1 2 3 4))
    (if (null? coll)
        nil
        (if (f (head coll))
            (head coll)
            (find f (tail coll)))))

(defun find-all (f coll)
;; Example: (find-all (lambda (x) (gt x 2)) (list 3 2 4 1))
    (filter f coll))

(defun and-then (f g)
    (lambda (x)
        (f (g x))))

(defun compose (f g)
    (lambda (x)
        (g (f x))))

(defun identity (x) x)

(defun invoke (f)
    (f))

(defun call (f args)
;; Example:
;; (defun add (a b) (+ a b))
;; (call add (list 1 2))
    (if (null? args)
        (f)
        (read
            (list
                (concat (quote f) args)))))

(defun partial (f x)
    (begin
        (defun iter (n f args)
            (if (gte (count args) n)
                (call f args)
                (lambda (x)
                    (begin
                        (define rest (flat-map identity (list x)))
                        (iter n f (concat args rest))))))
        (define rest (flat-map identity (list x)))
        (iter (arity f) f rest)))

(defun max-arity ()
    2147483591)