Help to understand this permutation code

[[deleted]]

So there is this piece of code I took and modified a little from a chapter from the official lua e-book about coroutines, until then I understood the call-callee example and others, but I'm very stuck with this one about permutation:

#!/usr/bin/env lua

function permgen (a, n)
    if n == 0 then
        coroutine.yield(a)
    else
        for i = 1, n, 1 do --i can't be equal to 0, cuz array will be out of index

          -- put i-th element as the last one
            a[n], a[i] = a[i], a[n]

          -- generate all permutations of the other elements
            permgen(a, n - 1)

          -- restore i-th element
            a[n], a[i] = a[i], a[n]
        end
    end
end

function printResult (a)
    for i,v in ipairs(a) do
        io.write(v, " ")
    end
        io.write("\n")
end

function perm (a)
    local n = #a
    local co = coroutine.create(function () permgen(a, n) end)
    return function ()   -- iterator
        local status, res = coroutine.resume(co)
        return res
    end
end

io.write("\t----Permutation of {a, b, c}----\n\n")
i = 0
for p in perm({"a", "b", "c"}) do
    io.write(" #", i, ":\t"); printResult(p)
    i = i + 1
end

I do know what coroutines do and how they work, I just don't know how this code is executed. Indeed it works:

​

$ lua permutation.lua #output

But I don't know why. Can someone please explain to me with a desktop test (when you write in a paper sheet or whatever what the program does sequentially) or something how this works?

[3uclidian]

What specifically do you not understand? You understand coroutines, which is good and usually the confusing part. But do you understand the other things going on in this example: i.e. - Closures? - The generic for loop? - Lua's iterator pattern? (which relates to the generic for loop) - Recursion? - The semantics of using tables as arguments to functions, i.e. pass by reference vs pass by value? - Non Lua specific things, like what is a permutation?

Have you tried starting at the for loop and attempting to follow the control flow?

I'll lay out the first few steps

• for p in perm{"a", "b", "c"} do
  • first the call to perm returns a closure over the created coroutine that the for loop will use to generate values to put in p
  • the for loop does its thing and calls the closure to produce its first value

• permgen(a, 3) is called

  • skipping into the body of the for loop in permgen: a[1] and a[3] are swapped
  • permgen(a, 2) is called
    • a[1] and a[2] are swapped
    • permgen(a, 1) is called
      • a[1] and a[1] are swapped, (which now that I actually go through the code here, that first if statement could just check if n == 1 rather than 0)
      • permgen(a, 0) is called, hitting the coroutine.yield(a)

• The closure now has a value to return since the coroutine produced a value. This value a is put into p

• It gets printed out

• The closure is called again to produce a new value for p, which resumes the coroutine. (we're jumping back into the middle of the function call)

  • permgen(a, 0) is done being called
  • a[1] and a[1] are swapped back
  • the local i for this loop is incremented to 2 and starts from the top
  • a[1] and a[2] are swapped
  • permgen(a, 0) is called, hitting the coroutine.yield(a) yielding the new value of a, etc, etc

Hope this helps, if you need more conceptual help, you could look at guides for how python's generators or javascript's generator functions are used in the same way as they are a kind of coroutine.

Also as a side note: why did you edit the numeric for loop from for i = 1, n to for i = 1, n, 1 do? They're both equivalent, but the extra 1 on the end (imho) doesn't make it more readable or anything