Can't wrap head around prototyping and metatables, how to implement this Java example?

public interface Transport {
public int getFuel();
public void refuel(int fuel);
public void driveTo(int x, int y);
};
public abstract class Vehicle implements Transport {
public final String brand;
public final String model;
public int fuel = 0;

public Vehicle(String brand, String model) {
  this.brand = brand;
  this.model = model;
}

public int getFuel() { return fuel; }
public int refuel(int fuel) { this.fuel += fuel; }
}
public class Car extends Transport {
public static int wheels;

public Car(String brand, String model) {
  super(brand, model);
}

public void driveTo(int x, int y) {
  // some stuff affecting fuel
}
}

local myFunc
local function callMyFunc()
  return myFunc("Hello")
end
myFunc = function(var1)
  print(var1)
end

callMyFunc()

local object = { --# define a simple object
  bar = "Hello World!";
}

function object:foo () --# create a function inside that object
  print(self.bar)
end

object:foo() --# prints 'Hello World!'

local object = {}

object.foo = 1

local object = setmetatable({}, { --# create a table and change it's metatable
  __newindex = function (t, k, v) --# define the metamethod'
    rawset(t, k, v + 1) --# modify the value
  end;
})

object.foo = 1

print(object.foo) --# prints '2'

local object = {
  bar = "test";
}

function object:foo (param)
  print(self.bar .. " " .. param)
end

local object = {
  bar = "test";
}

object.foo = function (self, param)
  print(self.bar .. " " .. param)
end

__call - Treat a table like a function. When a table is followed by parenthesis such as "myTable( 'foo' )" and the metatable has a __call key pointing to a function, that function is invoked (passing the table as the first argument, followed by any specified arguments) and the return value is returned

__call = function(...)
            constructor(prototype, ...)
            return prototype;
        end

KingofGamesYami, on 21 February 2016 - 10:00 PM said:

__call - Treat a table like a function. When a table is followed by parenthesis such as "myTable( 'foo' )" and the metatable has a __call key pointing to a function, that function is invoked (passing the table as the first argument, followed by any specified arguments) and the return value is returned

http://lua-users.org...MetatableEvents

Your __call looks like this:

__call = function(...)
			constructor(prototype, ...)
			return prototype;
		end

…which means you're calling constructor with 4 arguments. prototype, the table, width, and height.

MKlegoman357, on 21 February 2016 - 10:40 PM said:

The problem is that the 'self' argument passed to the constructor is the 'Rectangle' object itself. It's not creating a new table for you, it's simply passing the 'Rectangle' table. In the object's initialization (the __call metamethod) you should crate a new table, setup it's metatable and then call the constructor on that table.

__newindex - Control property assignment. When calling "myTable[key] = value", if the metatable has a __newindex key pointing to a function, call that function, passing it the table, key, and value.

• Use "rawset(myTable,key,value)" to skip this metamethod.
• (If the __newindex function does not set the key on the table (using rawset) then the key/value pair is not added to myTable.)

    __index = function( t, k )
        local temp = rawget( getmetatable( t ).realValues, k )
        local result = temp ~= nil and temp or getmetatable( t ).__super[ k ]
        if type( result ) == "function" then
            local env = getfenv( result )
            env.this, env.super = t, getmetatable( t ).__super
            setfenv( result, env )
        end
        return result
    end,

KingofGamesYami, on 21 February 2016 - 11:13 PM said:

If you want to control setting things in your table, you should use a blank table and assign an __newindex metamethod

__newindex - Control property assignment. When calling "myTable[key] = value", if the metatable has a __newindex key pointing to a function, call that function, passing it the table, key, and value.

• Use "rawset(myTable,key,value)" to skip this metamethod.
• (If the __newindex function does not set the key on the table (using rawset) then the key/value pair is not added to myTable.)

http://lua-users.org...MetatableEvents

Edit: For the super() constructer, you could do something similar to what I did in my example I posted earlier. I control the environment of the functions and insert certain variables. For instance, within my objects I can use this instead of self.

relevant part of my class

	__index = function( t, k )
		local temp = rawget( getmetatable( t ).realValues, k )
		local result = temp ~= nil and temp or getmetatable( t ).__super[ k ]
		if type( result ) == "function" then
			local env = getfenv( result )
			env.this, env.super = t, getmetatable( t ).__super
			setfenv( result, env )
		end
		return result
	end,

function class(constructor, class)
constructor = constructor or {}
class = class or {}

function class:new(...)
  local self = setmetatable({}, {
   __index = setmetatable(class, getmetatable(self));
  });

  constructor(self, ...);
  return self;
end
return class;
end
Rectangle = class(function(self, w, h)
self.w = w;
self.h = h;
end, { testA = 1 });
Square = class(function(self, size)
Rectangle.new(self, size, size);
end, { testB = 4 });
rect = Rectangle:new(2, 3);
square = Square:new(5, 6);
print(rect.w);
print(rect.h);
print(rect.testA);
print(rect.testB);
print(square.w);
print(square.h);
print(square.testA);
print(square.testB);

function class(construct, namespace)
construct = construct or {};
namespace = namespace or {};

function namespace:new(...)
  arg_metatable = getmetatable(self) or {};
  arg_supers = arg_metatable.supers or {};
  arg_supers[#arg_supers + 1] = namespace;

  local self = setmetatable({}, {
   supers = arg_supers;
   __index = function(object, key)
	for _, super in pairs(supers) do
	 if super[key] then return super[key] end;
	end
   end
  });

  construct(self, ...);
  return self;
end
return namespace;
end
Rectangle = class(function(self, w, h)
self.w = w;
self.h = h;
end, { testA = 1 });
Square = class(function(self, size)
Rectangle.new(self, size, size);
end, { testB = 4 });
rect = Rectangle:new(2, 3);
square = Square:new(5, 6);
print(rect.w);
print(rect.h);
print(rect.testA);
print(rect.testB);
print(square.w);
print(square.h);
print(square.testA);
print(square.testB);

function class(construct, namespace)
    construct = construct or {};
    namespace = namespace or {};

    -- object can be a class or an instance to inherit from
    namespace.new = function(object, ...)
        object_metatable = getmetatable(object) or {};
        object_inherits = object_metatable.inherits or {};

        new_inherits = object_inherits
        new_inherits[#new_inherits + 1] = namespace;
        new_instance = {};

        setmetatable(new_instance, {
            inherits = new_inherits,
            __index = function(instance, key)
                for _, inherit in pairs(inherits) do
                    if inherit[key] then return inherit[key] end
                end
            end
        });

        return new_instance;
    end

    return namespace;
end

Rectangle = class(
    function(self, w, h)
        self.w = w;
        self.h = h;
    end,
    { testA = 1 }
);

Square = class(
    function(self, size)
        Rectangle.new(self, size, size);
    end,
    { testB = 4 }
);

rect = Rectangle:new(2, 3);
square = Square:new(5, 6);

print(rect.w);
print(rect.h);
print(rect.testA);
print(rect.testB);

print(square.w);
print(square.h);
print(square.testA);
print(square.testB);

function class(super, namespace, constructor)
setmetatable(namespace, {
  __call = function(self, ...)
 
  end
});
end

local a = {}
setmetatable( a, {__index ={x=1}} )
print( a.x )
--#output: 1
local b = {}
setmetatable( b, {__index=a} )
print( b.x )
--#output: 1

KingofGamesYami, on 23 February 2016 - 11:05 PM said:

local a = {}
setmetatable( a, {__index ={x=1}} )
print( a.x )
--#output: 1
local b = {}
setmetatable( a, {__index=b} )
print( b.x )
--#output: 1

augustas656, on 23 February 2016 - 11:08 PM said:

The second output is nil because b has not defined x and b does not have a meta-table. The second setmetatable statement changes a's metatable from __index={x=1}; to b (which is {}, nothing).