Regarding avoid shallow copy, I wrote another version that achieve it via:

• Swap before recursion.
• Do recursion
• Swap back after recursion.

Thus there is only 1 copy of array during the execution.

Code

eight_queen_perm_inplace.lua:

--local inspect = require('inspect')
-- refer:   https://codereview.stackexchange.com/questions/293717       # SO question - code review,
N = 8   -- board size
z = 0   -- follow performance, by counting the time isplaceok() is called,


-- check whether position (n,c) is free from attacks
function isplaceok (a, n, c)
    z = z + 1
    for i = 1, n - 1 do
        -- for each queen already placed
        if (a[i] == c) or -- same column?
                (a[i] - i == c - n) or -- same diagonal?
                (a[i] + i == c + n) then
            -- same diagonal?
            return false            -- place can be attacked
        end
    end
    return true    -- no attacks; place is OK
end

-- print a board
function printsolution (a)
    for i = 1, N do
        -- for each row
        for j = 1, N do
            -- and for each column
            -- write "X" or "-" plus a space
            io.write(a[i] == j and "Q" or "-", " ")
        end
        io.write("\n")
    end
    io.write("\n")
end

-- add queen to board, via checking permutation,
function queenPermRecInplace(seq, arr, idx)
    if idx == #arr then
        -- need check last level,
        if isplaceok(arr, idx, arr[idx]) then
            seq = seq + 1
            --io.write(string.format("[%d] %s\n", seq, inspect(arr)))
            io.write(string.format("(%d)\n", seq))
            printsolution(arr)
        end
        return seq
    end

    for i = idx, #arr do
        -- swap, before recursion,
        swapArrElements(arr, idx, i)

        if isplaceok(arr, idx, arr[idx]) then
            -- stop early if not valid,
            seq = queenPermRecInplace(seq, arr, idx + 1)
        end

        -- swap back, after recursion,
        swapArrElements(arr, idx, i)
    end
    return seq
end

function swapArrElements(arr, a, b)
    tmpValue = arr[a]
    arr[a] = arr[b]
    arr[b] = tmpValue
end

function table.shallow_copy(t)
    local t2 = {}
    for k, v in pairs(t) do
        t2[k] = v
    end
    return t2
end

function table.join(t1, t2)
    for i = 1, #t2 do
        t1[#t1 + 1] = t2[i]
    end
    return t1
end

-- generate increase array in [1, n],
function genIncArr(n)
    arr = {}
    for i = 1, n do
        arr[i] = i
    end
    return arr
end

queenPermRecInplace(0, genIncArr(N), 1)
io.write(string.format("isplaceok() called %d times\n", z))

Concerns

• This is fine for single thread execution, to achieve parallel, copy array is necessary I think.
• Though there is no array copy, but it's not necessarily faster, in fact it might be slower than the array copy version.
• The permutation is not exactly in order now.