With Statement

wiki

Abstract

In several object oriented languages a with statement is implemented.

The structure like "with ... as" has a simple solution with a temporary variable, when one assigns the scope to the temporary variable and uses it whenever is needed.

The more complicated case, when "with" is used in order to extend the scope implicitly, like in the following example:

with (obj) {
some_method();
}

Lua doesn't provide such a structure by design. A simple solution is presented on this page.

Method

A basic library in lua provides enough instruments to implement something like "with" statement.

There's two functions to operate with environment: setfenv() and getfenv(), as well as a table _G exists.

"with" structure in common sense extends a scope with the provided object. It is possible with metadata manipulations (see getmetatable() and setmetatable()).

Lets see how to get such a thing in a Lua.

Solution

The subject structure can be implemented with the following function:

function with(env)
	local oldenv = getfenv(2);
	setfenv(2, env);
	return function() setfenv(2, oldenv) end;
end;

The return value is a function to restore the initial environment. Then, an outline of the structure will be:

local endwith = with (env)
	...
	any_method();
	...
endwith();

The main drawback of the method here is that we have no access to a variables from the initial scope. There're two simple ways to overcome the problem.

Save a global scope into a variable

A slightly modified function:

function with(env)
	local oldenv = getfenv(2);
	setfenv(2, env);
	return
		function() setfenv(2, oldenv) end,
		_G;
end;

Now the global scope is available:

local endwith, _G = with (env)
	...
	any_method();
	...
	_G.print("a function from a global scope");
	...
endwith();

Extend an object scope with _G

Another solution extends a specified scope with a _G:

function with(env)
	local oldenv = getfenv(2);
	local mt = getmetatable(env) or {};
	mt.__index = _G;
	setmetatable(env, mt);
	setfenv(2, env);
	return
		function() setfenv(2, oldenv) end,
		_G;
end;

Here the second return value may be omitted.

A global scope is available implicitly, like in othe languages:

local endwith = with (env)
	...
	any_method();
	...
	print("a function from a global scope");
	...
endwith();

Test

And a final test code:

-- tiny environment with the only function
Test = { output = function() print("\tTest.output()") end };

-- function for environment test
function output() print("Top-level output()") end;

-- the tricky with function
function with(env)
	local oldenv = getfenv(2);
	local mt = getmetatable(env) or {};
	mt.__index = _G;
	setmetatable(env, mt);
	setfenv(2, env);
	return
		function() setfenv(2, oldenv) end,
		_G;
end;

function main()
	output();
	--[[ ***
	local function output()
		print("*** the substituted function!");
	end;
	--]]
	local endwith, _G = with(Test);
		--[[ global environment still in _G table ]]
		_G.print("\texplicit print() invocation");
		--[[ implicit invocation ]]
		print("\timplicit print() invocation");
		--[[ call output here ]]
		output();
	endwith();
	--[[ environment restored outside of "with" ]]
	output();
end;

main();

You can uncomment the function marked with "***" for fun. It reveals a limitation, that one must keep in mind.

--IgorBogomazov?

Lua 5.2

LuaFiveTwo replaces getfenv and setfenv with _ENV, allowing with to be implemented as follows.

function with(...)
  local envs = {...}
  local f = (type(envs[#envs]) == 'function') and table.remove(envs)
  local env
  if #envs == 1 then
    env = envs[1]
  else
    local mt = {}
    function mt.__index(t, k)
      for i=1,#envs do
        local v = rawget(envs[i], k)
        if v ~= nil then return v end
      end
    end
    env = setmetatable({}, mt)
  end
  if f then
    return f(env)
  else
    return env
  end
end

-- test
local function print2(...) print('printing', ...) end

print 'one'
with({print=print2}, _ENV, function(_ENV)
  print('two', math.sqrt(4))
end)
print 'three'
do
  local _ENV = with({print=print2}, _ENV)
  print('four', math.sqrt(4))
end
print 'five'

--DavidManura

A dynamically scoped approach

Instead of using a do...end block to limit the scope of a 'with' statement, which does lexical scoping, one could explicitly switch it on or off, as in the following example.

with(math,string,table)
print("sin(1) = "..sin(1))  --> 0.8414709848079
print(format("The answer is %d",42)) --> The answer is 42
print(concat({"with","table","library"}," ")) --> with table library
without(string)
print(pcall(format,"The answer is %d",42))
--> false	attempt to call a nil value

The way in which this sort of 'with' statement works, is by chaining the __index fields of the metatables for _ENV, math, string and table. Here is the code.

with = function(...)
   local ENV = _ENV
   local mt = getmetatable(ENV)
   for k=1,select('#',...) do
      local tbl=select(k,...)
      local tblmt = getmetatable(tbl)
      if not mt then setmetatable(ENV,{__index=tbl})
      elseif not tblmt then 
         setmetatable(tbl,{__index=mt.__index}); mt.__index=tbl;
      elseif tbl~=mt.__index then
         error("bad argument to 'with': metatable already in use")
      end
      ENV, mt = tbl, tblmt
   end
end

The arguments appearing in the same 'with' statement are inserted in oder of decreasing priority. When 'concat' is not found in _ENV, math is searched; not in math, then string; not in string, then table.

However, the most recent 'with' statement takes precedence over all previous ones.

Note that, because of the "fallback" nature of metamethods, _ENV itself is always searched first.

The 'without' statement simply looks for the table in the chain, removes it, and rejoins the rest of the chain.

without = function(...)
   for k=1,select('#',...) do
      local mt = getmetatable(_ENV)
      if mt==nil then return end
      local tbl=select(k,...)
      local tblmt = getmetatable(tbl)
      while mt do
         local index = mt.__index
         if index == nil then mt=nil 
         elseif index == tbl then
            mt.__index = (tblmt and tblmt.__index) or nil; mt=nil
         else mt=getmetatable(index)
         end  
      end
   end
end

A side effect of this form of 'with' is that it implies an object hierarchy. After 'with(math,string,table)', for example 'math.sort' would be recognized until such time as 'without(table)' is executed.

It is also possible to insert a table in the chain directly below any table that is already in, or to remove a table from the 'with' chain only if it has lower priority than another table, thus:

do  
local with, without = with, without
with_this = function(_ENV,...) with(...) end
without_this = function(_ENV,...) without(...) end
end

with_this(table,string)     -- string comes below table
without_this(table,string)  -- string is disabled only if it
                            -- is below table

It is important to make upvalues for 'with' and 'without', otherwise they will not be found inside the functions since _ENV is being redefined.

: --DirkLaurie