; Aliases
(def first head)
(def rest tail)

; Increment a number by one
(def inc (fn (x) (+ x 1)))

; Decrement a number by one
(def dec (fn (x) (- x 1)))

; If a list is empty
(def empty?
  (fn (coll)
    (= (head coll) nil)))

; Modulus
(def mod
  (fn (x y) (- x (* (/ x y) y))))

; Returns a function that does the opposite of the given function
(def complement
  (fn (f) (fn (x) (not (f x)))))

; If a number is even
(def even?
  (fn (x) (= (mod x 2) 0)))

; If a number is odd
(def odd? (complement even?))

; Length of a list
(def len
  (fn (coll)
    (if (empty? coll)
      0
      (inc (len (tail coll))))))

; Gets an item in a list by index
(def nth
  (fn (index coll)
    (if (= 0 index)
      (head coll)
      (nth (dec index) (tail coll)))))

; Last item in list
(def last
  (fn (coll)
    (nth (dec (len coll)) coll)))

; Reverses a list
(def reverse
  (fn (coll)
    (reduce (fn (acc item) (cons item acc)) (list) coll)))

; Apply f to all items in list
(def map
  (fn (f coll)
    (if (= nil (head coll))
      coll
      (cons
        (f (head coll))
        (map f (tail coll))))))

; Go through a list passing an accumulator and each item of the list through f
; f(acc item)
(def reduce
  (fn (f acc coll)
    (if (empty? coll)
      acc
      (reduce f (f acc (head coll)) (tail coll)))))

; Filter a list of items based on a function
(def filter
  (fn (f coll)
    (reduce
      (fn (acc item) (if (f item) (cons item acc) acc))
      (list)
      (reverse coll))))

; Sum of all items in a list
(def sum
  (fn (coll)
    (reduce + 0 coll)))

; Take x items from list
(def take
  (fn (num coll)
    (if (= num 0)
      (list)
      (cons (head coll) (take (dec num) (tail coll))))))

; Drop x items from list
(def drop
  (fn (num coll)
    (if (= num 0)
      coll
      (drop (dec num) (tail coll)))))

; Exclusive range
(def range
  (fn (from to)
    (if (>= from to)
      (list)
      (cons from (range (inc from) to)))))

; Highest value in list
(def max
  (fn (coll)
    (reduce
      (fn (acc item) (if (< acc item) item acc))
      (head coll)
      (tail coll))))

; Lowest value in list
(def min
  (fn (coll)
    (reduce
      (fn (acc item) (if (> acc item) item acc))
      (head coll)
      (tail coll))))