Custom Operators

wiki

Hack: User-Defined Named Operators #1 (Infix)

Lua provides a small set of operators and a smaller set that you can override. The << operator, commonly used for inserting objects into a output stream in C++, is not one of them. That doesn't mean we can't try. The following code shows a scheme in which we can simulate the definition and use of custom operators in Lua.

-- Custom operator to evaluate (class)

local CustomOp = {}

function CustomOp:__div(b) -- eval full operation.

  return getmetatable(self.a)['__' .. self.op](self.a, b)

end

setmetatable(CustomOp, {__call =

  function(class, a, op) -- construct left-half of operation.

    return setmetatable({a = a, op = op}, CustomOp)

  end

})

function enable_custom_ops(mt) -- enable custom ops on metatable.

  function mt:__div(op)

    return CustomOp(self, op)

  end

  return mt

end



-- Output stream (class)

ostream  = {}

ostream.__index = ostream

enable_custom_ops(ostream)

function ostream:write(s)

  io.write(s)

end

ostream['__<<'] = function(self, s)  -- '<<' operator

  self:write(s)

  return self

end

setmetatable(ostream, {__call =

  function(class, file) -- construct output stream

    file = file or io.output()

    return setmetatable({file = file}, ostream)

  end

})

cout = ostream()

endl = "\n"  -- end of line



-- example usage



local _ = cout /'<<'/ "hello" /'<<'/ endl

--DavidManura, 200703

Hack: User-Defined Named Operators #2 (Infix)

This mimicks a similar [Python hack]:

local sm = setmetatable

local function infix(f)

  local mt = { __sub = function(self, b) return f(self[1], b) end }

  return sm({}, { __sub = function(a, _) return sm({ a }, mt) end })

end



local shl = infix(function(a, b) return a*(2^b) end)



print(5 -shl- 4)

--> 80

Cute, huh? Drawback: one table allocation per operation.

--MikePall, 2007-03-09

Hack: User-Defined Named Operators #3

local function factorial(n)

  local y = 1

  for i=2,n do y = y * i end

  return y

end



local function xor(a,b)

  assert(a == 3 and b == 4) -- an exercise for the reader!

  return 7                  -- or see http://lua-users.org/wiki/BitUtils

end



debug.setmetatable(0, {  -- create metatable for numbers

  __call = function(a, op)

   if op == '!' then return factorial(a)

   elseif op == 'xor' then return function(b) return xor(a,b) end

   end

  end

})



print(- (5)'!' + 1, - (3) 'xor' (4)) --> -119    -7

Note the precedence of operators: these are really function calls.

In the case of the unary postfix operators, there is no memory allocation, but there is for the binary op. We might improve that as follows (though unfortunately this is probably now relying on undefined behavior):

local savea

local function xorhelper(b)

  local a; a, savea = savea, nil

  return xor(a,b)

end

debug.setmetatable(0, {

  __call = function(a, op)

   if op == '!' then return factorial(a)

   elseif op == 'xor' then savea = a; return xorhelper

   end

  end

})

--DavidManura, 2007-07-14

See Also

• This is in LuaHacks
• "Mutate Operators" in LuaPowerPatches
• BitwiseOperators - bitwise operator support in Lua libraries or language
• PointAndComplex - when operating overloading is appropriate for points and complex number data types
• RiscLua supports additional built-in operators
• SyntaxAddition - suggestions to make Lua's built-in operators more like other languages
• TernaryOperator - suggestion to support a ternary conditional operator, like the cond ? expr1 : expr2 construct in C
• MetaLua [2] has an extensible parser that supports adding custom operators in the language