Carp/core/Macros.carp

(defdynamic cond-internal [xs]
  (if (= (count xs) 0)
    (list)
    (if (= (count xs) 2)
      (macro-error "cond has even number of branches; add an else branch")
      (if (= (count xs) 1)
        (car xs)
        (list
         'if
         (car xs)
         (car (cdr xs))
         (cond-internal (cdr (cdr xs))))))))

(defmacro cond [:rest xs]
  (cond-internal xs))

(defmacro for [settings body] ;; settings = variable, from, to, <step>
  (list
   'let
   (array (car settings) (car (cdr settings)))
   (list
    'while
    (list 'Int.< (car settings) (car (cdr (cdr settings))))
    (list 'do
          body
          (list
           'set! (list 'ref (car settings))
           (list 'Int.+
                 (car settings)
                 (if (= 4 (count settings)) ;; optional arg for step
                   (car (cdr (cdr (cdr settings))))
                   1)))))))

(defmacro refstr [x]
  (list 'ref
        (list 'str x)))

(defmacro foreach [f xs]
  (list 'for ['i 0 (list 'count (list 'ref xs))]
        (list f (list 'nth (list 'ref xs) 'i))))

(defdynamic thread-first-internal [xs]
  (if (= (count xs) 2)
    (if (list? (last xs))
      (cons (car (car (cdr xs)))
            (cons (car xs)
                  (cdr (car (cdr xs)))))
      (list (car (cdr xs)) (car xs)))
    (if (list? (last xs))
      (append
       (list
        (car (last xs))
        (thread-first-internal (all-but-last xs)))
       (cdr (last xs)))
      (list (last xs) (thread-first-internal (all-but-last xs))))))

(defdynamic thread-last-internal [xs]
  (if (= (count xs) 2)
    (if (list? (last xs))
      (cons-last (car xs) (last xs))
      (list (car (cdr xs)) (car xs)))
    (if (list? (last xs))
      (cons-last (thread-last-internal (all-but-last xs)) (last xs))
      (list (last xs) (thread-last-internal (all-but-last xs))))))

(defmacro => [:rest forms]
  (thread-first-internal forms))

(defmacro ==> [:rest forms]
  (thread-last-internal forms))

(defmacro swap! [x y]
  (list 'let (array 'tmp y) (list 'do (list 'set! &y x) (list 'set! &x 'tmp))))

(defmacro mac-only [:rest forms]
  (if (= "darwin" (os))
    (cons (quote do) forms)
    ()))

(defmacro linux-only [:rest forms]
  (if (= "linux" (os))
    (cons (quote do) forms)
    ()))

(defmacro windows-only [:rest forms]
  (if (= "windows" (os))
    (cons (quote do) forms)
    ()))

(defdynamic use-all-fn [names]
  (if (= (count names) 0)
    (macro-error "Trying to call use-all without arguments")
    (if (= (count names) 1)
      (list (list 'use (car names)))
      (cons (list 'use (car names)) (use-all-fn (cdr names))))));(use-all (cdr names))))))

(defmacro use-all [:rest names]
  (cons 'do (use-all-fn names)))

(defmacro when [condition form]
  (list 'if condition form (list)))

(defmacro unless [condition form]
  (list 'if condition (list) form))

(defmacro let-do [bindings :rest forms]
  (list 'let bindings
    (cons 'do forms)))

(defmacro defn-do [name arguments :rest body]
  (list 'defn name arguments (cons 'do body)))

(defmacro comment [:rest forms]
  ())

(defmacro forever-do [:rest forms]
  (list 'while true (cons 'do forms)))

(defdynamic case-internal [name xs]
  (if (= (count xs) 0)
    (list)
    (if (= (count xs) 2)
      (macro-error "case has even number of branches; add an else branch")
      (if (= (count xs) 1)
        (car xs)
        (list 'if
         (list '= name (car xs))
          (car (cdr xs))
          (case-internal name (cdr (cdr xs))))))))

(defmacro case [name :rest forms]
  (case-internal name forms))