From: shevegen@... Date: 2018-07-09T18:55:56+00:00 Subject: [ruby-core:87891] [Ruby trunk Feature#14904] Make it possible to run instance_eval with zero-arguments lambda Issue #14904 has been updated by shevegen (Robert A. Heiler). I have no particular pro or con opinion on the suggestion itself. I want to comment on one part though: > I've already found different solution - to use instance_exec instead of instance_eval. > But I'm still sure that life could be easier it instance_eval handled zero-argument > lambdas properly. I can't say whether instance_exec or instance_eval have similar or dissimilar use cases; I don't think I personally have ever used instance_exec though. But in the event that this is indeed the case, if there is already a "work-around", then perhaps this may yield credibility to your wanted use case for instance_eval to also allow for the same no argument passing as instance_exec would. But again, I am neutral on this and it may very well be likely that I do not fully understand the use case (I have to look up what instance_exec does after this :D). For me, mentally, the different evals are not very easy to remember. I use instance_eval a lot for class-method aliases, like via: self.instance_eval { alias foo bar } Not sure if there are alternatives to the above but if there are, it is not always easy to discover them (I mention this just loosely in regards to instance_exec but I think I am digressing too much from your issue, so I'll stop here.) ---------------------------------------- Feature #14904: Make it possible to run instance_eval with zero-arguments lambda https://bugs.ruby-lang.org/issues/14904#change-72904 * Author: prijutme4ty (Ilya Vorontsov) * Status: Open * Priority: Normal * Assignee: * Target version: ---------------------------------------- At a moment #instance_eval always yields an object to a given block. Though if we passed lambda as a block for instance_eval, its work depend on number of arguments. But I see no reason for such strictness when lambda gets zero arguments. In that case instance_eval can just skip yielding receiver to its block. It will reduce surprise for a newcomers who don't know the difference between proc and lambda. I got to this problem with code similar to this: ``` module ConfigParams def add_config_parameter(param_name, **kwargs, &block) # ... define_method(param_name){ kwargs[:default].call(self) } end end class KeyBindings extend ConfigParams add_config_parameter :undo add_config_parameter :redo, default: ->{ "shift+#{undo}" } end kb = KeyBindings.new kb.undo = 'ctrl+z' puts kb.redo # => shift+ctrl+z kb.redo = 'ctrl+y' ``` I want to allow user to express defaults with lambda which will be later evaluated in the context of an instance. It's a bit more readable than: ``` add_config_parameter :redo, default: proc{ "shift+#{undo}" } ``` And anyway, it'd be good if a user preferred to change proc into lambda didn't get strange exceptions. I've already found different solution - to use instance_exec instead of instance_eval. But I'm still sure that life could be easier it instance_eval handled zero-argument lambdas properly. Related: #10513 -- https://bugs.ruby-lang.org/ Unsubscribe: