8

Is it possible not to assign context to lambda?

For example:

class Rule
  def get_rule
    return lambda {puts name}
  end
end

class Person
  attr_accessor :name

  def init_rule 
    @name = "ruby"
    Rule.new.get_rule.call() # should say "ruby" but say what object of class Rull, does not have variable name
    # or self.instance_eval &Rule.new.get_rule
  end
end

My target is -> stored procedure objects without contexts, and assign context before call in specific places. Is it possible?

marc_s
  • 732,580
  • 175
  • 1,330
  • 1,459
vorobey
  • 4,401
  • 3
  • 18
  • 20
  • Just FYI; [this is a dupe](http://stackoverflow.com/questions/3133969/ruby-lambda-context), and searching google for "ruby bind context to lambda" provided that link plus others. – Dave Newton Sep 19 '11 at 12:38

3 Answers3

11

A bit late to party, but here's an alternate way of doing this by explicitly passing the context to the rule.

class Rule
  def get_rule
    return lambda{|context| puts context.name}
  end
end

class Person
  attr_accessor :name
  def init_rule
    @name = "ruby"
    Rule.new.get_rule.call(self)
  end
end

Person.new.init_rule
#=> ruby
forforf
  • 895
  • 7
  • 14
  • 3
    Definitely much better, but no need for the lambda here, it's just a method. I still feel apprehensive about code with dependencies like this, though. Problem comes when the rule calls methods that mutate the person, and now you can't understand how the person changes without also understanding everything the rules do. It gets worse when the rules are defined ad-hoc in random classes/files and you can't just go read the code to know. Passing the obj in is right, but rules should be as formalized as possible, and Person shouldn't be the one deciding to invoke them (push it up to the caller). – Joshua Cheek May 12 '14 at 09:40
10

Yeah, but be careful with it, this one is really easy to abuse. I would personally be apprehensive of code like this.

class Rule
  def get_rule
    Proc.new { puts name }
  end
end

class Person
  attr_accessor :name

  def init_rule 
    @name = "ruby"
    instance_eval(&Rule.new.get_rule)
  end
end
Joshua Cheek
  • 30,436
  • 16
  • 74
  • 83
1

In the spirit of being really late to the party ;-)

I think the pattern that you are using here is the Strategy pattern. This separates the concerns between the code that changes "rules" and the part that is re-used "person". The other strength of this pattern is that you can change the rules at run-time.

How it could look

class Person
  attr_accessor :name

  def initialize(&rules)
    @name = "ruby"
    instance_eval(&rules)
  end
end

Person.new do 
  puts @name
end

=> ruby
chrisz
  • 96
  • 3
  • Passing the rules in is better, but b/c it happens on initialization, there's no need, and this still suffers from the instance eval. – Joshua Cheek May 12 '14 at 09:44