Define_method with closures in Ruby - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a method named 'greet' that returns 'Hello'.

Ruby

class Person
  define_method(:greet) do
    [1]
  end
end

p = Person.new
puts p.greet

Drag options to blanks, or click blank then click option'

A"Hello"

BHello

Creturn Hello

Dputs "Hello"

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting quotes around Hello, causing a NameError.

Using puts inside the method instead of returning a string.

The method should return the string "Hello". Using quotes makes it a string literal.

2fill in blank

medium

Complete the code to define a method 'add' that takes one argument and adds it to 10.

Ruby

class Calculator
  define_method(:add) do |num|
    [1]
  end
end

calc = Calculator.new
puts calc.add(5)

Drag options to blanks, or click blank then click option'

A10 + num

Bnum + 10

Cnum - 10

D10 - num

Attempts:

3 left

💡 Hint

Common Mistakes

Subtracting instead of adding.

Swapping the order causing confusion.

Adding 10 to the argument num returns the sum. Both 'num + 10' and '10 + num' work.

3fill in blank

hard

Fix the error in the code to correctly define a method 'multiplier' that multiplies input by a fixed factor.

Ruby

class Multiplier
  def initialize(factor)
    @factor = factor
  end

  define_method(:multiply) do |num|
    num [1] @factor
  end
end

m = Multiplier.new(3)
puts m.multiply(4)

Drag options to blanks, or click blank then click option'

A/

B+

C-

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Using addition or subtraction instead of multiplication.

Using division which changes the result.

To multiply the input number by the factor, use the '*' operator.

4fill in blank

hard

Fill both blanks to define a method 'power' that raises input to a fixed exponent stored in @exp.

Ruby

class Power
  def initialize(exp)
    @exp = exp
  end

  define_method(:power) do |base|
    base [1] @exp
  end
end

p = Power.new(2)
puts p.power(5)

Drag options to blanks, or click blank then click option'

A**

B*

C+

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using multiplication instead of exponentiation.

Using addition or subtraction operators.

The '**' operator in Ruby raises a number to the power of another number.

5fill in blank

hard

Fill all three blanks to define a method 'describe' that returns a string with the object's name and age.

Ruby

class Person
  def initialize(name, age)
    @name = name
    @age = age
  end

  define_method(:describe) do
    "[1] is [2] years old."
  end
end

person = Person.new("Alice", 30)
puts person.describe

Drag options to blanks, or click blank then click option'

A@name

B@age

C"#{@name}"

D"#{@age}"

Attempts:

3 left

💡 Hint

Common Mistakes

Using variables without interpolation, resulting in literal text.

Using instance variables without quotes inside the string.

To insert instance variables into a string, use string interpolation with "#{variable}" syntax.

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