local function clone(object)
    local lookup_table = {}
    local function _copy(object) 
        if type(object) ~= "table" then
            return object 
        elseif lookup_table[object] then
            return lookup_table[object]
        end
        local new_table = {}
        lookup_table[object] = new_table
        for key, value in pairs(object) do
            new_table[_copy(key)] = _copy(value)
        end
        return setmetatable(new_table, getmetatable(object))
    end
    return _copy(object)
end

local function class(super)
    local cls

    if (super) then
        cls = clone(super)
    else
        cls = {
            ctor = function()
            end
        }
    end

    function cls.new(...)
        local sets, gets = {}, {}
        local instance = setmetatable({ },
        {
            __index = function(t, k)
                if gets[k] then
                    return gets[k]()
                end
                return cls[k]
            end,
            __newindex = function(t, k, v)
                if sets[k] then
                    return sets[k](v)
                end
                rawset(t, k, v)
            end,
        })
        if instance.setter or instance.getter then
            error("error : Prohibition of override 'setter' and 'getter' Function;");
        end
        instance.setter = function(_, name, func)
            instance[name] = nil
            sets[name] = func
            return instance
        end
        instance.getter = function(_, name, func)
            gets[name] = func
            return instance
        end

        instance.class = cls
        instance:ctor(...)
        return instance
    end

    return cls
end

local a = class()
function a:ctor()
    print("a")
end
function a:funcA()
    print("funcA")
end
------------------
local b = class(a)
function b:ctor()
    a.ctor(self)
    print("b")
end
function b:funcB()
    print("funcB")
end
------------------
local c = class(b)
function c:ctor()
    b.ctor(self)
    print("c")
    self._x = nil;
    self:setter("x",function (v)
        self._x = v;
        print("setter x:" .. v)
    end)
    self:getter("x",function()
        print("getter x:" .. self._x)
        return self._x;
    end)
end
function c:funcC()
    print("funcC")
    return self
end
------------------
local d = class(c)
function d:ctor()
    c.ctor(self)
    print("d")
end

local t = d.new()
t:funcA()
t.x = "hello";
print(t.x);
t:funcC():funcB()