crafted a macro for doing "(let loop ((arg1 val1) ...) body ...)" wondering if any alternatives there is already existing

[Inc0n]

Picking up janet again for doing a side project, missing the "let loop" recursion when needed doing some simple recursion in a functional manner, it looks like a powerful loop macro exist but for other purposes. So why not write my own.

(defmacro label [name args & body]
  (let [table (from-pairs args)]
    ~(do (def ,name (fn ,name ,(apply tuple (keys table)) ,;body))
      (,name ,;(values table)))))

it worked for my simple case, choosing the name of label partly due to commonlisp labels but also let and loop are already taken right? I want to know if any existing solution is out there already that I have missed. If not would it be a good addition to janet possibly?

[sogaiu]

May be somewhat similar to "named let" from Scheme [1] [2] or named-let in Emacs Lisp?

FWIW, label is a name that is already used in janet.

---

[1] Search for "Named let" here.

[2] Named let in Scheme

[Inc0n]

yeap, it is "named let" I was trying to replicate here. Thanks for the documentations, wasn't aware it's called "named let". As well as the pointer to label wasn't aware of that as well.
named-let would naturally be a good alternative as such.

[ianthehenry]

It’s hard to think of possible existing alternatives without seeing some uses — can you give an example of where you’d use this over a loop? I’m thinking this could be a useful way to define a walk callback but I’m not sure if it would fit into anything I’ve written myself.

[Inc0n]

Sure, I see. Well I haven't used janet extensive enough to think myself knowing whether an alternative exist or not.
Here is how I used it (replacing the name label to named-let here)

(defn main [self & args]
  (named-let lp [(counter 0)]
    (prinf "%d> " counter)
    (when (file/read stdin :line)
      (lp (+ 1 counter)))))

I found myself in need of writing a simple application that just increment a counter whenever enter is hit. Coming from using scheme, there was the (let loop-name ((arg1 init-val1) ...) body ...) approach, my preference would of course be strongly desired to write it in the form which I did above.

[sogaiu]

Perhaps the following is somewhat close to the spirit of the original:

(defn main [self & args]
  ((fn lp [counter]
     (prinf "%d> " counter)
     (when (file/read stdin :line)
       (lp (+ 1 counter))))
    0))

[ianthehenry]

For non-branching recursion where you're always recursing in tail position, I think simple iteration would more idiomatic. That said this would still be a nice way to define loops on complicated recursive structures. I think using unwrapped binding pairs looks more natural in Janet:

# "immediately invoked function expression"
(defmacro iife [name bindings & body]
  (def bindings (partition 2 bindings))
  [['fn name (tuple ;(map 0 bindings)) ;body] ;(map 1 bindings)])

(defn main [self & args]
  (iife lp [counter 0]
    (prinf "%d> " counter)
    (when (file/read stdin :line)
      (lp (+ 1 counter)))))

(Mirroring the syntax of (let [counter 0] ...).)

I'm occasionally annoyed that there's no natural way to express something like a do-while loop in Janet, but I like this structure for that.