Feature #21973: Smile argument

• Status: Rejected
• Assignee: -
• Target version: -

[kinoppyd (Yasuhiro Kinoshita)]

Ruby makes us smile. So I want Ruby to smile too, and that is why I would like to propose this feature.

The smile argument makes Ruby smile by allowing a method call to end its argument list with :).

smile_method(arg, :)

This syntax implicitly supplies keyword arguments by matching the names of local variables in the current scope with the names of the method’s keyword parameters.

For example, if a method has the following signature:

some_method(arg, smile:, hugging:)

then these two calls would be equivalent:

arg = "hello"  
smile = "smile"  
hugging = "hugging"  
some_method(arg, smile:, hugging:)

arg = "hello"  
smile = "smile"  
hugging = "hugging"  
some_method(arg, :)

The motivation behind this feature is the assumption that names used in a method signature are often also used at the call site.

For instance, if a library method defines keyword arguments like (from:, to:), I expect that code using that method would often have local variables named from and to holding the actual values before passing them along.

In real application development, when developers adopt a new library, they will usually look at the argument list of the method they want to call. If they intend to use that method as designed, it seems natural that they may also choose the same variable names as those in the method signature.

This idea was inspired by Scala’s implicit parameters. It is not exactly the same feature, but as a lazy person, I find the idea of context-driven currying quite appealing.

In any case, the real purpose is to make Ruby smile.

Happy Ruby! And happy April Fools' Day!

[ko1 (Koichi Sasada)]

Implementation should be easy like that :)

def q(a:, b:1)
  p a:, b: #=> {a: 10, b: 20}
end

def smile_send mid, b, *params
  h = {}

  method(mid).parameters.each do |(type, key)|
    case type
    when :keyreq
      h[key] = b.local_variable_get(key)
    when :key
      h[key] = b.local_variable_get(key) if binding.local_variable_defined?(key)
    else
      raise
    end
  end

  send mid, *params, **h
end

a = 10
b = 20

# q( :) #=> will be compiled to
smile_send :q, binding

[vo.x (Vit Ondruch)]

• File clipboard-202603312047-a8wkw.png clipboard-202603312047-a8wkw.png added

My email client does not like this proposal:

Maybe :)) (even bigger smile) should be considered instead?

[matz (Yukihiro Matsumoto)]

• Status changed from Open to Rejected

Thanks for the proposal. I'd like to decline.

Ruby already lets you omit values in the keyword shorthand: some_method(arg, smile:, hugging:) is equivalent to some_method(arg, smile: smile, hugging: hugging). That covers most of the brevity, while keeping the keyword names visible at the call site.

What :) adds is making the names themselves disappear. When I read some_method(arg, :), I cannot tell from the call site what is being passed. I have to look up the method definition. The keyword names at the call site are not just noise: they serve as documentation, and they make the call robust against changes in the method's keyword list. If the method later renames a keyword, an explicit caller breaks loudly, while a :) caller may silently pick up an unrelated local variable or fail in a more confusing way.

Concise and easy to read are not the same thing. Here I'd rather keep the names.

Matz.