(def drop (n|whole xs)
  (if (= n 0)
      xs
      (drop (- n 1) (cdr xs))))

(def nth (n|pint xs|pair)
  (if (= n 1)
      (car xs)
      (nth (- n 1) (cdr xs))))

(vir num (f args)
  `(nth ,f ,@args))

(def nchar (n)
  (car ((+ n 1) chars)))

(def first (n|whole xs)
  (if (or (= n 0) (no xs))
      nil
      (cons (car xs)
            (first (- n 1) (cdr xs)))))

(mac catch body
  (letu v
    `(ccc (fn (,v) (bind throw ,v ,@body)))))

(def cut (xs (o start 1) (o end (len xs)))
  (first (- (+ end 1 (if (< end 0) (len xs) 0))
            start)
         (drop (- start 1) xs)))

(mac whenlet (var expr . body)
  `(iflet ,var ,expr (do ,@body)))

(mac awhen args
  `(whenlet it ,@args))

(mac each (var expr . body)
  `(map (fn (,var) ,@body) ,expr))

(def flip (f)
  (fn args (apply f (rev args))))

(def part (f . args)
  (fn rest
    (apply f (append args rest))))

(def trap (f . args)
  (flip (apply part (flip f) (rev args))))

(def only (f)
  (fn args
    (if (car args) (apply f args))))

(def >= args
  (pairwise ~bin< args))

(def <= args
  (apply >= (rev args)))