macro.md

A little Clojure challenge inspired by Let over Lambda.

Write a macro (you can try a function, but it's impossible) that accepts four arguments:

1. an expression that returns a number
2. something to return if that number's negative
3. something to return if that number's zero
4. something to return if that number's positive

Here's the signature: (defmacro nif [expr neg zero pos] ...)

To pass my test, the following form should print "pos!" and return "pos.", with no other side effects:

(nif 10
      (do (println "Negative!") "negative.")
      (do (Thread/sleep 1000000) "zero.")
      (do (println "pos!") "pos."))

May the best lisper win!

Does this count as well? No macros used, I promise :P

class Number {
  def negative: neg zero: zero positive: pos {
    match self {
      case 0 -> zero
      case @{ < 0 } -> neg
      case _ -> pos
    } call
  }
}

# prints "pos!" and returns "pos."
10 negative: {
  "negative!" println; "negative."
} zero: {
  Thread sleep: 1000000; "zero."
} positive: {
  "pos!" println; "pos."
}

Nice! FancyLang for the WIN! Are you passing in functions to be called depending on the condition?

Fun little puzzle! Thanks :-)

@sritchie Kind of. They're blocks and allow non-local returns but in this case that doesn't matter. They're similar to regular lambdas. :)

I'm not sure, since you're saying it is impossible without a macro I must have misunderstood something:

(defn nif [exp neg zero pos]
  (let [e (if (instance? clojure.lang.IFn exp) (exp) exp)]
    (cond (> 0 e) (neg)
          (== 0 e) (zero)
          (< 0 e) (pos))))

macro'y solution in my fork

@mdiin - your solution does:

user> (nif 10
      (do (println "Negative!") "negative.")
      (do (Thread/sleep 1000000) "zero.")
      (do (println "pos!") "pos."))
pos!
Negative!
"pos."

Ah, right. Because the do special form evaluates the expressions - I had missed that and wrapped each of the (do ...) in a function.

@mdiin yeah, the trick with the macro here is that a function evaluates all of it's arguments, so you have to scramble a bit to prevent that evaluation. The nif macro lets you think of the inputs as unevaluated lists (or numbers, or whatever they happen to be), and shuffle them into the proper form before they hit the compiler.

@samaaron Thanks! The next quiz will be,

Write a series of macros that wraps clojure.core in a badass, composable, music-generating fiesta of code.

@sritchie :-) I'll work on a solution...