Dynamically calling methods

[exists-forall]

In both Lua and Moonscript, the only way to call a method with an implicit self parameter is for the name of the method to be known at compile time, like obj\method .... If you want to call a method with a dynamically determined name, you no longer have syntactic sugar to hide the rather redundant self parameter. For example:

love.keypressed = (k)->
  key_handler_obj["#{k}_pressed"] key_handler_obj

which is pretty ugly IMHO, and can lead to subtle bugs if you forget to add the second self.

I propose Moonscript implement a obj\[metname] syntax to handle such cases. With this new syntax, our code could become

love.keypressed = (k)->
  key_handler_obj\["#{k}_pressed"]!

for simple cases where the receiver is just a variable,

obj\[dyn_metname] args...

could compile to

obj[dyn_metname](obj, args...)

for more complicated cases where the method call is not being used as an expression you could use a do block to prevent extra evaluations:

love.keypressed = (k)->
  get_key_handler!\["#{k}_pressed"]!

should become

love.keypressed = function(k)
  do
    local _dynam_0 = get_key_handler()
    return _dynam_0[tostring(k) .. "_pressed"](_dynam_0)
  end
end

When there is an assignment statement and the receiver is not a simple variable, you can slightly modify the compiled code

love.keypressed = (k)->
  result = get_key_handler!\["#{k}_pressed"]!

should compile to

love.keypressed = function(k)
  local result
  do
    local _dynam_0 = get_key_handler()
    result = dynam_0[tostring(k) .. "_pressed"](_dynam_0)
  end
end

when all else fails, I.E. it's used directly within an expression and the receiver is not a simple variable, use the elegant but less efficient route of creating an anonymous function

love.keypressed = (k)->
  print get_key_handler!\["#{k}_pressed"]!

should become

love.keypressed = function(k)
  return print((function()
    local _dynam_0 = get_key_handler()
    return _dyam_0[tostring(k) .. "_pressed"](_dynam_0)
  end)())
end

[leafo]

I like this, I've definitely come across situations where I've wanted to add it before.

[stevedonovan]

That is a good suggestion. It's always been one of those irritating things in Lua...

[lordnynex]

Bump! Ugly syntax or not, I'm grateful this issue was posted because I just burned over an hour trying to figure out how to do this.

[ThaisRobba]

I quite like the general idea - syntax should be carefully thought out though.

One workaround, meanwhile, is to create a closure, like this:

key_handler_closure = (key, ...) -> key_handler_obj["#{key}_pressed"] key_handler_obj, ...

love.keypressed = (k) -> key_handler_closure k

[Idyllei]

I personally don't like the look of object\["#{var}_method"] ...
for dynamic method calls. I would greatly prefer a more concise form, perhaps one that allows programs to be more dynamic.

I think it would look great to use a syntax that is similar to string interpolation ("#{var}"), such as:

object\{CODE GOES HERE} ...

With this, we code put some code between { } which will return a string corresponding to the method to be called.

object\{if _DEBUG then 'foo' else 'bar'} baz

could be understood as

do
    if _DEBUG
        object['foo'] object, baz
    else
        object['bar'] object, baz

EDIT: I have (perhaps) come up with a more Moonscript-to-Lua way of interpreting the syntax..

do
    local _dyn_meth_obj_0 = object  -- Maybe we could think of a better name?
    local _meth_name_0 = nil
    if _DEBUG
        _meth_name_0 = 'foo'
    else
        _meth_name_0 = 'bar'
    _dyn_meth_obj_0[_meth_name_0] _dyn_meth_obj_0, baz

Of course, the code between the brackets would have to be given its own private (sandboxed) scope. Otherwise one could inadvertently alter the surrounding scope.

[lordnynex]

@branefreez 👍 The current @\["#var_method"] syntax is unintuitive because it doesn't visually make sense. A valid use case for this is a custom logging object that directs input to a log method to a more specific @config.logLevel handler.