[ruby-core:125159] [Ruby Feature#21973] Smile argument

31 Mar 2026

      Issue #21973 has been updated by ko1 (Koichi Sasada).

Implementation should be easy like that :)

```ruby
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
```

----------------------------------------
Feature #21973: Smile argument
https://bugs.ruby-lang.org/issues/21973#change-116891

* Author: kinoppyd (Yasuhiro Kinoshita)
* Status: Open
----------------------------------------
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:

```ruby
some_method(arg, smile:, hugging:)
```

then these two calls would be equivalent:

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

```ruby
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!

-- 
https://bugs.ruby-lang.org/