diff --git a/libs/module.lua b/libs/module.lua
index 0116e83..29b7b86 100644
--- a/libs/module.lua
+++ b/libs/module.lua
@@ -1,23 +1,21 @@
 if module then return end
-local type, setmetatable, setfenv, unpack, next, intersection, union, pcall, _G = type, setmetatable, setfenv, unpack, next, bit.band, bit.bor, pcall, getfenv(0)
+local type, setmetatable, setfenv, unpack, next, pcall, _G = type, setmetatable, setfenv, unpack, next, pcall, getfenv(0)
 local start_declaration, declaration, env_mt, interface_mt, noop_mt
 
-local PRIVATE, PUBLIC, PROPERTY = 0, 1, 2
 local INDEX, NEWINDEX, CALL = 1, 2, 3
-local _state = {}
 
-local function error(message, ...)
-	return _G.error(format(message or '', unpack(arg))..'\n'..debugstack(), 0)
-end
+local function error(msg, ...) return _G.error(format(msg or '', unpack(arg))..'\n'..debugstack(), 0) end
 local function import_error() error 'Invalid imports.' end
 local function declaration_error() error 'Invalid declaration.' end
 local function collision_error(key) error('"%s" already exists.', key) end
 
-local function noop() end
+local function nop() end
 local function id(_) return _ end
---function vararg_id(...) return unpack(arg) end
 local function const(_) return function() return _ end end
---function vararg_const(...) return function() return unpack(arg) end end
+--local function vararg_id(...) return unpack(arg) end
+--local function vararg_const(...) return function() return unpack(arg) end end
+
+local _state, _public, _type = {}, {}, {}
 
 do
 	local function extract(v)
@@ -30,46 +28,55 @@ do
 	local function declare(self, modifiers, key, value)
 		local metadata = self.metadata
 		metadata[key] = metadata[key] and collision_error(key) or modifiers
-		if intersection(PROPERTY, modifiers) == 0 then
+		if intersection(ACCESSOR, modifiers) == 0 then
 			self.methods[key] = value
 		else
 			local success, f, mutator = pcall(extract, value)
 			if success or declaration_error() then
-				self.methods[key], self.mutators[key] = type(f) == 'function' and f or const(f), mutator or noop
+				self.methods[key], self.mutators[key] = type(f) == 'function' and f or const(f), mutator or nop
 			end
 		end
 	end
 
-	declaration = noop
+	declaration = nop
 	do
-		local MODIFIER = {private=PRIVATE, public=PUBLIC, property=PROPERTY}
-		local state, modifiers, property
-		local function intercept(self, type, key, value)
+		local PUBLIC = {public=true, private=false}
+		local PREFIX_TYPE = {method=CALL, accessor=INDEX, mutator=NEWINDEX}
+		local SUFFIX_TYPE = {call=CALL, get=INDEX, set=NEWINDEX}
+		local state, access, type, name
+		local function intercept(self, event, key, value)
 			if self ~= state then declaration_error() end
-			if type == INDEX and (not property or declaration_error()) then
-				local modifier = MODIFIER[key]
-				if not modifier then modifier, property = PROPERTY, key end
-				modifiers = union(modifiers, modifier)
+			if event == INDEX and (not name or declaration_error()) then
+				if ACCESS[key] then
+					access = (access and declaration_error()) or ACCESS[key]
+				elseif PREFIX_TYPE[key] then
+					type = (type and declaration_error()) or PREFIX_TYPE[key]
+				elseif not type or declaration_error() then
+					name = key
+				end
 				return true
-			elseif type == NEWINDEX then
-				if property then key, value = property, {[key]=value} end
-				declare(self, union(modifiers, self.modifiers), key, value)
-				declaration = noop
+			elseif event == NEWINDEX then
+				if name then
+					type = SUFFIX_TYPE[key] or declaration_error()
+					key = name
+				end
+				declare(self, access, type, key, value)
+				declaration = nop
 				return true
-			elseif type == CALL then
-				if property then declare(self, union(modifiers, self.modifiers), property, value) else self.modifiers = modifiers end
-				declaration = noop
+			elseif event == CALL then
+				if name then declare(self, access, type, name, value) else self.access, self.type = access, type end
+				declaration = nop
 				return true
 			end
 		end
 		function start_declaration(self, modifier)
-			if declaration ~= noop then declaration_error() end
+			if declaration ~= nop then declaration_error() end
 			declaration, state, modifiers, property = intercept, self, modifier, nil
 		end
 	end
 
 	env_mt = {__metatable=false}
-	function env_mt:__index(key, state) state=_state[self]
+	function env_mt:__index(key) local state=_state[self]
 		if declaration(state, INDEX, key) then return self end
 		if intersection(PROPERTY, state.metadata[key] or 0) ~= 0 then
 			return state.getters[key]()
@@ -78,12 +85,12 @@ do
 			if value ~= nil then return value else return _G[key] end
 		end
 	end
-	function env_mt:__newindex(key, value, state) state=_state[self]
+	function env_mt:__newindex(key, value) local state=_state[self]
 		if declaration(state, NEWINDEX, key, value) then return end
 		local modifiers = state.metadata[key]
 		if modifiers then
 			if intersection(PROPERTY, modifiers) ~= 0 then
-				state.setters[key](value)
+				state.mutators[key](value)
 			end
 		else
 			declare(state, state.modifiers, key, value)
@@ -95,7 +102,7 @@ do
 end
 
 interface_mt = {__metatable=false}
-function interface_mt:__index(key, state) state=_state[self]
+function interface_mt:__index(key) local state=_state[self]
 	local masked = intersection(PUBLIC+PROPERTY, state.metadata[key] or 0)
 	if masked == PUBLIC+PROPERTY then
 		return state.getters[key]()
@@ -103,41 +110,45 @@ function interface_mt:__index(key, state) state=_state[self]
 		return state.methods[key]
 	end
 end
-function interface_mt:__newindex(key, value, state) state=_state[self]
+function interface_mt:__newindex(key, value) local state=_state[self]
 	if intersection(PUBLIC+PROPERTY, state.metadata[key] or 0) == PUBLIC+PROPERTY then
-		return state.setters[key](value)
---	elseif masked == PUBLIC and type(state.methods[key]) == 'function' then
---		return state.methods[key](value)
+		return state.mutators[key](value)
+	elseif masked == PUBLIC and type(state.methods[key]) == 'function' then
+		return state.methods[key](value)
 	end
 end
+function interface_mt:__call(key, ...) local state=_state[self]
+	-- TODO new instance
+end
 
-noop_mt = {__index=function() return noop end}
+noop_mt = {__index=function() return nop end}
 
 function module(...)
 	local state, env, interface
 	env, interface = setmetatable({}, env_mt), setmetatable({}, interface_mt)
 	state = {
-		metadata = {_=PROPERTY, error=PRIVATE, noop=PRIVATE, _G=PRIVATE, M=PRIVATE, I=PRIVATE, private=PROPERTY, public=PROPERTY, property=PROPERTY},
+		metadata = {_=ACCESSOR, error=PRIVATE, nop=PRIVATE, _G=PRIVATE, M=PRIVATE, I=PRIVATE, private=ACCESSOR, public=ACCESSOR, accessor=ACCESSOR},
 		methods = setmetatable({
 			_G = function() return _G end,
 			M = function() return env end,
 			I = function() return interface end,
 			private = function() start_declaration(state, PRIVATE); return env end,
 			public = function() start_declaration(state, PUBLIC); return env end,
-			property = function() start_declaration(state, PROPERTY); return env end,
+			accessor = function() start_declaration(state, ACCESSOR); return env end,
+			mutator = function() start_declaration(state, MUTATOR); return env end,
 			error = error,
-			noop = noop,
+			nop = nop,
 			id = id,
 			const = const,
 		}, noop_mt),
-		setters = setmetatable({}, noop_mt),
+		mutators = setmetatable({}, noop_mt),
 		modifiers = PRIVATE,
 	}
 	for i=1,arg.n do
 		local module = state[arg[i] or import_error()] or import_error()
 		for k, v in module.metadata do
 			if intersection(PUBLIC, v) ~= 0 and (not state.metadata[k] or import_error()) then
-				state.metadata[k], state.methods[k], state.getters[k], state.setters[k] = v, module.methods[k], module.getters[k], module.setters[k]
+				state.metadata[k], state.methods[k], state.mutators[k] = v, module.methods[k], module.mutators[k]
 			end
 		end
 	end