(def! dec (fn* (a) (- a 1)))

(def! zero? (fn* (n) (= 0 n)))

(def! reduce
  (fn* (f init xs)
    (if (empty? xs)
      init
      (reduce f (f init (first xs)) (rest xs)))))

(def! identity (fn* (x) x))

(def! every?
  (fn* (pred xs)
    (if (empty? xs)
      true
      (if (pred (first xs))
        (every? pred (rest xs))
        false))))

(def! some
  (fn* (pred xs)
    (if (empty? xs)
      nil
      (let* (res (pred (first xs)))
        (if res
          res
          (some pred (rest xs)))))))

(defmacro! and
  (fn* (& xs)
    (if (empty? xs)
      true
      (if (= 1 (count xs))
        (first xs)
        (let* (condvar (gensym))
          `(let* (~condvar ~(first xs))
            (if ~condvar (and ~@(rest xs)) ~condvar)))))))

(defmacro! ->
  (fn* (x & xs)
    (if (empty? xs)
      x
      (let* (form (first xs)
             more (rest xs))
        (if (empty? more)
          (if (list? form)
            `(~(first form) ~x ~@(rest form))
            (list form x))
          `(-> (-> ~x ~form) ~@more))))))

(defmacro! ->>
  (fn* (x & xs)
    (if (empty? xs)
      x
      (let* (form (first xs)
             more (rest xs))
        (if (empty? more)
          (if (list? form)
            `(~(first form) ~@(rest form) ~x)
            (list form x))
          `(->> (->> ~x ~form) ~@more))))))

; This `nil` is intentional so that the result of doing `load-file` is
; `nil` instead of whatever happens to be at the end of `core.mal`.
nil