052num.wart

let ($+) (+)
  def! (+ ... args)
    (reduce ($+) args 0)

let ($-) (-)
  def! (- ... args)
    (reduce ($-) args)

let ($*) (*)
  def! (* ... args)
    (reduce ($*) args 1)

let ($/) (/)
  def! (/ ... args)
    (reduce ($/) args)

let ($%) (%)
  def! (% ... args)
    (reduce ($%) args)

mac ++n
  `(zap! (+) ,n 1)

mac --n
  `(zap! (-) ,n 1)

def (- n ... rest) :case no.rest
  (- 0 n)



let ($<) (<)
  def (< ... args) :case ($< 2 len.args)
    (and (all (fn((x y)) (x < y))
              pairwise.args)
         last.args)

def (> ... args)
  (aand (all (fn((x y)) (y < x))
             pairwise.args)
        (or last.args it))

def (<= ... args)
  (aand (none predicate.nil args)
        (none (fn((x y)) (y < x))
              pairwise.args)
        (or last.args it))

def (>= ... args)
  (aand (none predicate.nil args)
        (none (fn((x y)) (x < y))
              pairwise.args)
        (or last.args it))

def (min ... args)
  (best (<) args)

def (max ... args)
  (best (>) args)

def (< scorer ... rest) :case (and fn?.scorer no.rest)
  (fn(x y)
    (aif (scorer.x < scorer.y)
      y
      false))

def (> scorer ... rest) :case (and fn?.scorer no.rest)
  (fn(x y)
    (aif (scorer.x > scorer.y)
      y
      false))



def (zero? n)
  (n = 0)

def (divides nr dr)
  (zero? nr%dr)

def (even? n)
  (divides n 2)

alias odd? ~even?

def (sum seq)
  (+ @seq)

def (product seq)
  (* @seq)

def (abs n)
  if (n < 0) -n :else n

mac (add! x|to y)
  `(,x <- (+ ,x ,y))
mac! (a += b)
  `(add! ,a ,b)

mac (sub! x|from y)
  `(,x <- (- ,x ,y))
mac! (a -= b)
  `(sub! ,a ,b)

mac (mul! x y|by)
  `(,x <- (* ,x ,y))
mac! (a *= b)
  `(mul! ,a ,b)

mac (div! x y|by)
  `(,x <- (/ ,x ,y))
mac! (a /= b)
  `(div! ,a ,b)