Define_method with closures in Ruby - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does define_method do in Ruby?

define_method creates a new method dynamically with a given name and block of code.

beginner

What is a closure in Ruby?

A closure is a block, proc, or lambda that remembers the variables from the place where it was defined, even if called elsewhere.

intermediate

How does define_method use closures?

The block passed to define_method acts as a closure, capturing variables from the surrounding scope to use inside the new method.

intermediate

Example: What will this code output?<br><pre>class Greeter
  def initialize(name)
    @name = name
    self.class.define_method(:greet) do
      "Hello, #{@name}!"
    end
  end
end

g = Greeter.new("Alice")
puts g.greet</pre>

The output will be Hello, Alice! because the block captures @name from the instance.

intermediate

Why is it useful that define_method blocks are closures?

It lets the dynamically created method access variables from where it was defined, allowing flexible and powerful method creation.

What does the block passed to define_method capture?

A Variables from the surrounding scope (closure)

B Only global variables

C Nothing, it has no access to outside variables

D Only method arguments

The block acts as a closure, capturing variables from where it was defined.

Which keyword is used to create a method dynamically in Ruby?

A def_method

B define_method

C create_method

D method_define

define_method is the correct Ruby method to define methods dynamically.

If a variable is defined outside define_method block, can the method access it?

A Yes, because the block is a closure

B No, it can only access its own variables

C Only if the variable is global

D Only if passed as an argument

The block remembers variables from its defining scope, so it can access them.

What will happen if you call define_method inside an instance method?

A It causes a syntax error

B It defines a method only for that instance

C It defines a global method

D It defines a method on the class using the closure of the instance method

The method is defined on the class, but the block can capture instance variables from the instance method.

Why might you use define_method with closures?

A To avoid using instance variables

B To speed up method calls

C To create methods that remember specific data from when they were defined

D To create global variables

Closures let the method remember data from its creation context, making it flexible.

Explain how define_method uses closures to access variables from its defining scope.

Think about how blocks remember variables around them.

Describe a simple example where define_method with a closure can be useful in Ruby.

Imagine creating personalized greeting methods.

Practice

1. What does define_method do in Ruby?

easy

A. Defines a class variable

B. Deletes an existing method

C. Calls a method immediately

D. Creates a method dynamically using a block

Solution

1. Step 1: Understand the purpose of define_method

   define_method is used to create methods dynamically at runtime using a block of code.

2. Step 2: Compare with other options

   Options B, C, and D describe different actions unrelated to define_method.

3. Final Answer:

   Creates a method dynamically using a block -> Option D

4. Quick Check:

   define_method creates methods dynamically [OK]

Hint: Remember: define_method builds methods with blocks [OK]

Common Mistakes:

• Thinking define_method calls methods
• Confusing define_method with deleting methods
• Assuming it defines variables

2. Which of the following is the correct syntax to define a method named greet using define_method that returns "Hello"?

easy

A. def define_method(:greet) "Hello" end

B. define_method greet { return "Hello" }

C. define_method(:greet) { "Hello" }

D. define_method(:greet, "Hello")

Solution

1. Step 1: Recall correct define_method syntax

   The correct syntax uses a symbol for the method name and a block: define_method(:name) { ... }.

2. Step 2: Check each option

   def define_method(:greet) "Hello" end uses def incorrectly. define_method greet { return "Hello" } lacks symbol (greet undefined). define_method(:greet, "Hello") passes string instead of block. B matches correct syntax.

3. Final Answer:

   define_method(:greet) { "Hello" } -> Option C

4. Quick Check:

   Correct syntax uses symbol and block [OK]

Hint: Use symbol and block for define_method syntax [OK]

Common Mistakes:

• Using method name without symbol
• Incorrect block syntax
• Using def inside define_method

3. What will be the output of this Ruby code?

class Person
  def initialize(name)
    @name = name
    self.class.define_method(:greet) { "Hello, #{@name}!" }
  end
end

p = Person.new("Alice")
puts p.greet

medium

A. Hello, Alice!

B. Hello, !

C. NoMethodError

D. SyntaxError

Solution

1. Step 1: Understand closure and instance variable scope

   The block passed to define_method defines the method body. However, the string interpolation "Hello, #{@name}!" is evaluated immediately when define_method is called, not when the method is invoked. At that time, @name is nil because the block is defined in the class context, not the instance context.

2. Step 2: Predict output

   Therefore, the method greet returns the string with @name interpolated as nil, resulting in "Hello, !".

3. Final Answer:

   Hello, ! -> Option B

4. Quick Check:

   String interpolation in define_method block evaluated immediately [OK]

Hint: String interpolation in define_method block is evaluated immediately [OK]

Common Mistakes:

• Thinking @name is dynamically resolved inside the block
• Expecting 'Hello, Alice!' due to misunderstanding of closure
• Confusing instance and class scope

4. Identify the error in this code snippet:

class Calculator
  def initialize(x)
    @x = x
    self.class.define_method(:square) { @x * @x }
  end
end

calc = Calculator.new(4)
puts calc.square

medium

A. No error, outputs 16

B. Syntax error in define_method block

C. The block does not capture @x correctly, causing nil * nil error

D. The method square is not defined for instances

Solution

1. Step 1: Analyze where define_method is called

   define_method on self.class defines an instance method square. The block executes in instance context.

2. Step 2: Understand closure and instance variable scope

   @x resolved on instance: 4 * 4 = 16. No capture issue, no error.

3. Final Answer:

   No error, outputs 16 -> Option A

4. Quick Check:

   Instance vars work in class-level define_method [OK]

Hint: Instance vars work in class-level define_method blocks [OK]

Common Mistakes:

• Thinking method undefined for instances
• Expecting syntax error
• Believing nil * nil error from poor capture

5. How can you fix this code so that each instance of Person has a greet method that correctly uses its own @name?

class Person
  def initialize(name)
    @name = name
    self.class.define_method(:greet) { "Hello, #{@name}!" }
  end
end

p1 = Person.new("Bob")
p2 = Person.new("Carol")
puts p1.greet
puts p2.greet

hard

A. Define greet method inside initialize using define_singleton_method

B. Use self.class.define_method but pass @name as parameter

C. Move @name to a class variable

D. Use def greet; "Hello, #{@name}!"; end inside initialize

Solution

1. Step 1: Understand the problem with class-level define_method

   Class-level define_method in initialize redefines a shared instance method each time (inefficient, problematic for local var closures). Instance vars work via dynamic lookup.

2. Step 2: Use define_singleton_method to define method per instance

   define_singleton_method defines on the instance's singleton class, giving each its own greet accessing own @name.

3. Final Answer:

   Define greet method inside initialize using define_singleton_method -> Option A

4. Quick Check:

   Use define_singleton_method for per-instance closures [OK]

Hint: Use define_singleton_method for instance-specific methods [OK]

Common Mistakes:

• Trying to pass instance vars as parameters to class method
• Using class variables instead of instance variables
• Defining method with def inside initialize incorrectly