048control.wart

mac (do1 ... body)
  `(ret $ret ,car.body
     ,@cdr.body)

mac (between before after|and ... body)
  `(do1
     (do ,before ,@body)
     ,after)

mac (before cleanup ... body)
  `(do1
     (do ,@body)
     ,cleanup)

mac (when cond ... body)
  `(if ,cond
     (do ,@body))

mac (unless cond ... body)
  `(if (not ,cond)
     (do ,@body))

mac (iflet var expr ... branches)
  if no.branches
    expr
    `(let $tmp ,expr
       (if $tmp
         (let ,var $tmp
           ,car.branches)
         ,(if cdr.branches
            `(iflet ,var ,@cdr.branches))))

mac (iflet var x op test then ... branches) :case (op = :satisfies)
  `(let ,var ,x
     (if (,test ,var)
       ,then
       (iflet ,var ,@branches)))

mac (aif expr ... branches)
  `(iflet it ,expr ,@branches)

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

mac (awhen test ... body)
  `(whenlet it ,test
      ,@body)

mac (aand ... args)
  if no.args
       1
     ~cdr.args
       car.args
     :else
       `(aif ,car.args
          (aand ,@cdr.args))



mac (while test ... body)
  `(when ,test
     ,@body
     (while ,test
       ,@body))

mac (whilet var test ... body)
  `(let $var ,test
     (when $var
       (let ,var $var
         ,@body)
       (whilet ,var ,test
         ,@body)))

mac (awhile test ... body)
  `(whilet it ,test
     ,@body)

mac (for var start test update ... body)
  `(let ,var ,start
     (while ,test
       ,@body
       ,update))

mac (each var expr ... body)
  `(for $i (as list ,expr) $i (zap! cdr $i)
      (let ,var car.$i
        ,@body))

mac (on var expr ... body)
  `(for ($i index) (list ,expr 0) $i  (do (zap! cdr $i) ++index)
     (let ,var car.$i
       ,@body))

mac (forlen var expr ... body)
  `(for ,var 0 (< ,var (len ,expr)) (++ ,var)
     ,@body)

mac (repeat n ... body)
  `(for $i 0 (< $i ,n) ++$i
     ,@body)

mac (repeat n ... body) :case (n = :forever)
  `(while 1 ,@body)



# (f&g x) => (and (f x) (g x))
# multiply-evals by design to support macros
def (& ... fs)
  (fn 'args
    (eval `(and ,@(map :over fs
                       :with (fn(f) `(,f ,@args))))
          caller_scope))

def (| ... fs)
  (fn 'args
    (eval `(or ,@(map :over fs
                      :with (fn(f) `(,f ,@args))))
          caller_scope))

mac (&~ f g)
  `(,f & (~ ,g))



def (functionize f)
  if (and (cons?&car.f ~= 'fn)
          (mem? '_ f))
    `(fn(_) ,f)
    f

mac (x -> f)
  `(,functionize.f ,x)

mac (transform x ... fs|thru)
  if no.fs
    x
    `(transform (,x -> ,car.fs) ,@cdr.fs)