In Nspire Lua, it is exactly the goal of the class() function. But as you want it to be also usuable in standard Lua, I guess you should look at this

But ... there is another problem.

In Lua, everything is tables .. and most likely I'm interested in the way someone will handle call errors on elements likes the one you describe. IMHO it is impossible the way you want the errors to be handled.

Also, Lua is multitype, so this : matrix1[1][1] = "2" --converts to number

matrix1[1][1] = true --error
will be possible only with direct calls to functions. The way you want it to be is not possible in Lua, same in many languages.... but I can be wrong.

matrix1[1][1] will be possible with something like this :

matrix1 = {{1, 2, 3}, {4, 5, 6}, ["add"]=function(self, m2) end}

getmetatable(matrix), but yes, it was just to show the content of matrix1.
matrix.new is the function described in the link I gave you.

Here is the class function (although slightly modified):
class = function(prototype)
local derived={}

  if prototype then
derived.__proto = prototype
  function derived.__index(t,key)
  return rawget(derived,key) or prototype[nobbc]
  end
  else
  function derived.__index(t,key)
  return rawget(derived,key)
  end
  end
 
  function derived.__call(proto,...)
  local instance={}
  setmetatable(instance,proto)
  instance.__obj = true
  local init=instance.init
  if init then
  init(instance,...)
  end
  return instance
  end
 
  setmetatable(derived,derived)
  return derived
end
I think you want something like this:

Matrix = class()

function Matrix:init(mat)
    self.matrix = mat
end

function Matrix:set(x, y, n)
    self.matrix[y][x] = n
end


matrix1 = Matrix{{1,2,3},{1,2,3},{1,2,3}}
matrix2 = Matrix{{1,2,3},{1,2,3}}

matrix1:set(1,1,3)

matrix1 and matrix2 are not connected in anyway. You can expand the matrix class to your wishes.
Also, with metatables/-methods you could even make that matrix3=matrix1+matrix2 is possible

If you don't want users to have direct write access to the table, you can use something like this:


function createProxy(tbl)
local mt = {}
local proxy = {}
mt.__index = function (_, key)
return tbl[ key]
end

mt.__newindex = function ()
print("You are not allowed to write to this table!")
end
setmetatable(proxy, mt)
return proxy
end


a = createProxy{1,2,3,4,5}

print(a[2])
a[2] = 3

I'm taking a look at your code.

Edit: ouch, the forum is changing table keys to nobbc
Edit2: Okay, I think class you be something for you. You should be able to protect your variables enough.

Well, here is almost the same for a matrix:

function createProxy(tbl)


local mt = {}
local proxy = {}
mt.__index = function (t, key)
local rownumber = rawget(t, "rownumber")
if rownumber then
return tbl[ rownumber][ key]
else
return tbl[ key]
end
end

mt.__newindex = function ()
print("You are not allowed to write to this table!")
end

for key, row in ipairs(tbl) do
proxy[ key] = {}
proxy[ key].rownumber = key
setmetatable(proxy[ key], mt)
end

setmetatable(proxy, mt)

return proxy
end


a = createProxy{{5,4,3,2,1},{3,6,9,1}}

print(a[ 2][ 3])
a[ 2][ 3] = 3
print(a[ 2][ 3])


It should not allow it. You can modify __newindex so to parse the input and possible modify it.
The above code is just the concept, you can build on it and make it do what you want.

Edit: wait, it does. Let me fix it

Okay, I guess you just need to modify some things to get it working.
However, why don't you just make the matrix local to your functions, so only your functions can access it ?
That way you could have matrix.getValue and matrix.setValue. Matrix[ y][ x] would not work. That way you don't need to deal with lot's of stuff.