Bug #12521
Updated by nobu (Nobuyoshi Nakada) over 7 years ago
There is an interesting style of programming that is *almost* really easy to do in Ruby. It would work elegantly with a simple change. A double-colon keyword argument should be available that will still leave the same argument captured by a double-splat argument if present. With this available, it becomes easy to pass down a "context" through a call chain. Consider this: ```ruby ``` def controller name::, **context … log_then_render something:, name:, **context end def log_then_render **context log context complex_logic_then_render **context end def complex_logic_then_render name::, **context … Bunch of further calls def render name::, something::, **context … end ``` Now assume I decide render needs a foo argument, that I obtain in my controller. The only functions that are aware of or have any need for the argument are controller and render. With functions written in this style, I only need to modify the two functions that need to know about the argument: ```ruby ``` def controller name::, **context … log_then_render something:, name:, foo: foo_value, **context end … no changes … def render name::, something::, foo:: **context … now use foo … end ``` This is, I accept, unusual. I've not seen a language that offers this sort of feature (I call them, for various reason I don't have time to go into now, FREST functions). I can basically implement this now with a decorator, but it's a little ugly and slow. It just occurred to me that an alternative would be a triple-splat final argument (or some such) that gathers all the keywords. There is a related problem with the way double-splat and regular keyword arguments interact that should be fixed anyway.