loop.compiler.Conditional
Class of objects that executes selected pieces of a chunk of Lua code. This class is useful for generating optimized functions that avoids condition tests or other constructions when such actions can be previously identified as unecessary. Since the execution of the selected pieces of the code chunk may be relatively slow, this approach is preferable for creation of optmized function that are generated rarely but are evaluated constantly.
Each object contains a list of pairs that contain a chunk of Lua code and a Lua expression that defines whether the chunk should be executed or not, e.g. used in the generation of a customized function. When the conditional code is executed, a table is provided containing the options used to select the appropriate pieces of the chunk.
Behavior
Fields
name[optional]-
Name of the compiled conditional code that is used in error messages (this name is used in the call of function
loadstringthat compiles the conditional code).
Methods
source(options)-
Generate the source containing only selected pieces of the chunk that are identified by the evaluation of each associated conditional expressions with the values provided by
options. execute(options, ...)-
Compiles and executes the selected pieces of the chunk that are identified by the evaluation of each associated conditional expressions with the values provided by
options. The aditional parameters are passed to the conditional code being executed. All the values returned by the conditional code is retured by this function.
Remarks
- The creation of customized functions implies in compilation and evaluation of each conditional expression as well as chunk concatenation, compilation and execution, therefore it results in a very expensive operation.
Examples
Classes with __index meta-method.
local oo = require "loop.base"
local Conditional = require "loop.compiler.Conditional"
local indexer = Conditional{
{ [[local class = ... ]] },
{ [[local index = class.__index ]], "indextype ~= 'nil'" },
{ [[local super = select(2, ...) ]], "supercount > 0" },
{ [[return function(self, field) ]] },
{ [[ local value ]] },
{ [[ = index[field] ]], "indextype == 'table'" },
{ [[ = index(self, field) ]], "indextype == 'function'" },
{ [[ if value == nil then ]], "indextype ~= 'nil'" },
{ [[ value = class[field] ]] },
{ [[ if value == nil then ]], "supercount > 0" },
{ [[ value = super[field] ]], "supercount == 1" },
{ [[ for _, super in ipairs(super) do]], "supercount > 1" },
{ [[ value = super[field] ]], "supercount > 1" },
{ [[ if value ~= nil then break end]], "supercount > 1" },
{ [[ end ]], "supercount > 1" },
{ [[ end ]], "supercount > 0" },
{ [[ end ]], "indextype ~= 'nil'" },
{ [[ return value ]] },
{ [[end ]] },
}
function class(class, ...)
local options = {
supercount = select("#", ...),
indextype = type(class.__index),
}
local super
if options.supercount <= 1
then super = ...
else super = { ... }
end
class.__index = indexer:execute(options, class, super)
return oo.class(class)
end
Class = class(
-- class fields
{
classfield = "classfield",
__index = function(_, field)
if field == "dynamicfield" then
return field
end
end,
},
-- superclasses
{ inherited1 = "inherited1" },
{ inherited2 = "inherited2" }
)
Object = Class{ objectfield = "objectfield" }
print("Object.objectfield = "..Object.objectfield )
print("Object.classfield = "..Object.classfield )
print("Object.dynamicfield = "..Object.dynamicfield)
print("Object.inherited1 = "..Object.inherited1 )
print("Object.inherited2 = "..Object.inherited2 )