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/

Issue #21973 has been updated by 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. ---------------------------------------- Feature #21973: Smile argument https://bugs.ruby-lang.org/issues/21973#change-117565 * Author: kinoppyd (Yasuhiro Kinoshita) * Status: Rejected ---------------------------------------- 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! ---Files-------------------------------- clipboard-202603312047-a8wkw.png (30.3 KB) -- https://bugs.ruby-lang.org/