A nest macro

[yohannd1]

Hello, I've made something I'm quite proud of, though I haven't quite tested its usefulness yet:

(defmacro nest
  "Created a nested expression from the sequence of forms in `body`. All arguments, except the last one, must be lists.
  Every element is nested as the last element its predecessor, such that the first element is the outermost list.

  As an example:
  (nest
    (for i 0 3)
    (for j 0 3)
    (pp [i j]))

  Is the same as:
  (for i 0 3
    (for j 0 3)
      (pp [i j]))
  "
  [& body]

  (def [forms end]
    (if (empty? body)
      [[] nil]
      [(array/slice body 0 (dec (length body)))
       (last body)]))

  (var result end)

  (var i (dec (length forms)))
  (while (>= i 0)
    (def form (in forms i))
    (assert (tuple? form) (string/format "form should be a tuple, got %j" form))
    (set result [;form result])
    (-- i))

  result)

It's mostly inspired on the flexibility of the loop macro, but aiming to work with general functions. I imagine this works with let, defer and prompt, for example.
Does anyone know of similar macros in other lisps (or perhaps even Janet - I might've glossed over it)? I'm curious if this approach has been taken before, because it feels really powerful.

[ianthehenry]

This is the ->> macro with the arguments reversed:

repl:1:> (macex1 '(->>
  (pp [i j])
  (for j 0 3)
  (for i 0 3)))
(for i 0 3 (for j 0 3 (pp [i j])))

The ordering of ->> makes sense if you're using it with functions, as it lets you write code like (->> [1 2 3] (map |(* 2 $)) (filter |(> $ 3))) to do things "in order", since function evaluation is kinda inside out. When chaining control-flow macros, your argument order is more natural. But I've never seen that before and I'm having trouble imagining when I would reach for it... although I reach for loop and friends all the time and this could just make an easier to parse version. Interesting idea!

[yohannd1]

Oh, I hadn't thought about that usage of ->>, really cool!