Is a function defined in a loop created at each iteration?

[amano-kenji]

Or, is it created only once and given the new fiber environment each time?

What about a function defined in a recursive function?

[sogaiu]

I examined the disassembly output of what seemed like an example of the kind of code the question may have been referring to:

(disasm (fn [] (for i 0 2 (defn my-fn [x] (+ x 1)))))
# =>
'{:arity 0
  :bytecode @[(ldi 0 0) 
              (ldi 1 2) 
              (clo 2 1) 
              (call 2 2) 
              (retn)]
  :constants @[]
  :defs @[{:arity 1
           :bytecode @[(addim 2 0 1) (ret 2)]
           :constants @[]
           :defs @[]
           :environments @[]
           :max-arity 1
           :min-arity 1
           :name "my-fn"
           :slotcount 3
           :source "repl"
           :sourcemap @[(3 43) (3 43)]
           :structarg false
           :symbolmap @[(0 2 0 x) (0 2 1 my-fn)]
           :vararg false} 
          {:arity 0
           :bytecode @[(ldu 1 0 0)
                       (ldu 2 0 1)
                       (lt 0 1 2)
                       (jmpif 0 2)
                       (retn)
                       (ldu 1 0 0)
                       (clo 2 0)
                       (ldu 4 0 0)
                       (addim 2 4 1)
                       (setu 2 0 0)
                       (lds 4)
                       (tcall 4)]
           :constants @[]
           :defs @[{:arity 1
                    :bytecode @[(addim 2 0 1) (ret 2)]
                    :constants @[]
                    :defs @[]
                    :environments @[]
                    :max-arity 1
                    :min-arity 1
                    :name "my-fn"
                    :slotcount 3
                    :source "repl"
                    :sourcemap @[(3 43) (3 43)]
                    :structarg false
                    :symbolmap @[(0 2 0 x) (0 2 1 my-fn)]
                    :vararg false}]
           :environments @[-1]
           :max-arity 2147483647
           :min-arity 0
           :name "_while"
           :slotcount 5
           :source "repl"
           :sourcemap @[(3 16)
                        (3 16)
                        (3 16)
                        (3 16)
                        (3 16)
                        (3 16)
                        (3 27)
                        (3 16)
                        (3 16)
                        (3 16)
                        (3 16)
                        (3 16)]
           :structarg false
           :symbolmap @[(:upvalue 0 0 _00000r) 
                        (:upvalue 0 1 _00000s) 
                        (5 12 1 i) 
                        (7 12 3 my-fn)]
           :vararg false}]
  :environments @[]
  :max-arity 0
  :min-arity 0
  :slotcount 3
  :source "repl"
  :sourcemap @[(3 16) (3 16) (3 16) (3 16) (3 16)]
  :structarg false
  :vararg false}spoiler

My initial impression is that (clo 2 0) is called in a loop (loop implemented via tail-calling i.e. (tcall 4)).

I think what (clo 2 0) calls is what's in here:

           :defs @[{:arity 1
                    :bytecode @[(addim 2 0 1) (ret 2)]
                    :constants @[]
                    :defs @[]
                    :environments @[]
                    :max-arity 1
                    :min-arity 1
                    :name "my-fn"
                    :slotcount 3
                    :source "repl"
                    :sourcemap @[(3 43) (3 43)]
                    :structarg false
                    :symbolmap @[(0 2 0 x) (0 2 1 my-fn)]
                    :vararg false}]

JOP_CLOSURE (which IIUC is what implements clo) seems to create a new function (closure).

For reference, "closure" here, may mean this.

So, tentatively, "yes" to the original question because it looks to me like clo (something that creates a function / closure) is being called in a loop.

[amano-kenji]

What is the original question?

[sogaiu]

Apparently you wrote the following as the title of this discussion:

Is a function defined in a loop created at each iteration?

[amano-kenji]

Does this mean defn in a loop or a recursive function is inefficient because defn is evaluated from scratch at every iteration?

[sogaiu]

I don't think the parsing and compiling happens every iteration (i.e. the translation from a string of Janet code to Janet data structures being the parsing and the further translation of the Janet data structures to bytecode being the compilation).

After compilation has finished and bytecode is arrived at, I don't think there is a defn any more. What remains as part of the bytecode is a request to create a closure via the JOP_CLOSURE bytecode instruction. The implementation suggests to me that execution of JOP_CLOSURE involves creating a new JanetFunction.

That code looks to me like its putting together fn (a JanetFunction) by reusing bytecode that has already been arrived at via earlier and "holding on" to 0 or more environments.

That seems consistent with what the website docs say about closures:

All functions in Janet are closures; they combine some bytecode instructions with 0 or more environments.

Put another way, when one uses (defn ...), it seems to me that one is asking for a closure to be created. If that's an issue in some loop-like situation, perhaps in some cases the code that involves loops or recursion can be expressed in a way such that (defn ...) can happen "elsewhere" (e.g. for a loop, put the (defn ...) outside of the loop).

[amano-kenji]

If the new fiber environment is passed to a compiled function at each iteration, then it should be efficient.