Prepend for method chain insertion in Ruby - Step-by-Step Execution

Concept Flow - Prepend for method chain insertion

Define original class

↓

Define module with new method

↓

Prepend module to class

↓

Create instance

↓

Call method

↓

Module method runs first

↓

Call super to original method

↓

Original method runs

↓

Combined output

This flow shows how prepending a module inserts its methods before the original class methods, allowing method chaining with super.

Execution Sample

Ruby

class Greeter
  def greet
    "Hello"
  end
end

module Enthusiastic
  def greet
    super + "!!!"
  end
end

Greeter.prepend(Enthusiastic)
puts Greeter.new.greet

This code prepends a module to add excitement to the greet method by chaining with super.

Execution Table

Step	Action	Method Called	Result	Output
1	Create Greeter class with greet method	N/A	greet returns "Hello"	N/A
2	Define Enthusiastic module with greet method	N/A	greet calls super + "!!!"	N/A
3	Prepend Enthusiastic to Greeter	N/A	Enthusiastic methods inserted before Greeter	N/A
4	Create Greeter instance	N/A	Instance ready	N/A
5	Call greet on instance	Enthusiastic#greet	Calls super	N/A
6	Inside Enthusiastic#greet calls super	Greeter#greet	Returns "Hello"	N/A
7	Enthusiastic#greet adds "!!!"	N/A	Returns "Hello!!!"	N/A
8	Print output	N/A	Output is "Hello!!!"	Hello!!!

💡 Method chain completes after Enthusiastic#greet returns combined string.

Variable Tracker

Variable	Start	After Step 4	After Step 7	Final
instance	nil	Greeter instance	Greeter instance	Greeter instance
method_call	none	none	super called inside greet	greet returns "Hello!!!"
output	none	none	none	"Hello!!!"

Key Moments - 3 Insights

Why does the module's greet method run before the class's greet method?

Because prepending inserts the module before the class in the method lookup chain, so the module's method is found first (see execution_table step 5).

What does the super keyword do inside the module's greet method?

It calls the original greet method from the class that was prepended, allowing method chaining (see execution_table step 6).

What would happen if we didn't call super in the module's greet method?

The original greet method would not run, so the output would only be what the module returns, missing the original "Hello" (not shown in table but implied).

Visual Quiz - 3 Questions

Look at the execution_table, at which step is the original Greeter#greet method called?

A Step 7

B Step 5

C Step 6

D Step 8

💡 Hint

Check the 'Method Called' column for when Greeter#greet runs.

According to variable_tracker, what is the output after step 7?

A nil

B No output yet

C "Hello"

D "Hello!!!"

💡 Hint

Look at the 'output' variable value after step 7.

If we remove the super call in Enthusiastic#greet, what changes in the output?

A Output becomes "!!!"

B Output becomes "Hello"

C Output becomes "Hello!!!"

D Output is empty

💡 Hint

Recall that super calls the original method; without it, only the module's addition remains.

Concept Snapshot

Prepend inserts a module before a class in method lookup.
Module methods run first, can call super to chain.
Use prepend to add behavior before original methods.
Example: module with greet calls super + "!!!".
Prepending modifies method chain order.

Full Transcript

This visual trace shows how Ruby's prepend works to insert a module's methods before a class's methods. First, the Greeter class defines greet returning "Hello". Then, the Enthusiastic module defines greet calling super plus "!!!". Prepending Enthusiastic to Greeter changes the method lookup order so Enthusiastic#greet runs first. When greet is called on a Greeter instance, Enthusiastic#greet runs, calls super which runs Greeter#greet returning "Hello", then adds "!!!" to produce "Hello!!!". The output is printed. Variables track the instance creation, method calls, and final output. Key moments clarify why the module method runs first and the role of super. Quizzes test understanding of method call order and output changes. The snapshot summarizes prepend usage for method chain insertion.

Practice

1. What does the prepend keyword do in Ruby when used with a module and a class?

easy

A. It inserts the module before the class in the method lookup chain.

B. It appends the module after the class in the method lookup chain.

C. It replaces the class methods with the module methods permanently.

D. It creates a copy of the module inside the class without affecting method lookup.

Solution

1. Step 1: Understand method lookup order with prepend

   Using prepend places the module before the class in the method lookup chain, so module methods are checked first.

2. Step 2: Compare prepend with other module inclusion methods

   Unlike include which adds the module after the class, prepend inserts it before, changing method resolution order.

3. Final Answer:

   It inserts the module before the class in the method lookup chain. -> Option A

4. Quick Check:

   Prepend = module methods run first [OK]

Hint: Prepend means module methods run before class methods [OK]

Common Mistakes:

• Confusing prepend with include
• Thinking prepend replaces class methods permanently
• Assuming prepend appends module after class

2. Which of the following is the correct syntax to prepend a module Mod to a class MyClass?

easy

A. class MyClass; extend Mod; end

B. class MyClass; include Mod; end

C. class MyClass; prepend Mod; end

D. class MyClass; insert Mod; end

Solution

1. Step 1: Recall Ruby syntax for prepend

   The correct syntax to prepend a module is prepend ModuleName inside the class definition.

2. Step 2: Eliminate other options

   include adds module after class, extend adds methods as class methods, and insert is invalid syntax.

3. Final Answer:

   class MyClass; prepend Mod; end -> Option C

4. Quick Check:

   Prepend syntax = prepend ModuleName [OK]

Hint: Use 'prepend ModuleName' inside class to insert module first [OK]

Common Mistakes:

• Using include instead of prepend
• Using extend which affects class methods
• Typing invalid keywords like insert

3. What is the output of this Ruby code?

module M
  def greet
    "Hello from M, " + super
  end
end

class C
  prepend M
  def greet
    "Hello from C"
  end
end

puts C.new.greet

medium

A. "Hello from C"

B. "Hello from M, Hello from C"

C. NoMethodError

D. "Hello from M"

Solution

1. Step 1: Understand method lookup with prepend

   Because M is prepended, its greet method is called first.

2. Step 2: Follow the super call in module method

   The super inside M#greet calls the original greet in C, returning "Hello from C".

3. Step 3: Combine returned strings

   The module method returns "Hello from M, " + "Hello from C" resulting in "Hello from M, Hello from C".

4. Final Answer:

   "Hello from M, Hello from C" -> Option B

5. Quick Check:

   Prepend + super calls original method [OK]

Hint: Prepend runs module method first; super calls original method [OK]

Common Mistakes:

• Ignoring super call and expecting only module output
• Thinking prepend replaces original method without super
• Expecting NoMethodError due to super

4. Identify the error in this Ruby code using prepend:

module M
  def hello
    super + " world"
  end
end

class C
  prepend M
end

puts C.new.hello

medium

A. TypeError because prepend is used incorrectly

B. No error; outputs " world"

C. SyntaxError due to missing method in class

D. NoMethodError because super has no method to call

Solution

1. Step 1: Check method definitions

   The module M defines hello calling super, but class C has no hello method.

2. Step 2: Understand super call behavior

   Since C has no hello, super has no method to call, causing a NoMethodError.

3. Final Answer:

   NoMethodError because super has no method to call -> Option D

4. Quick Check:

   Super needs original method; missing causes NoMethodError [OK]

Hint: Super must call existing method; else NoMethodError [OK]

Common Mistakes:

• Assuming super works without original method
• Thinking prepend fixes missing methods automatically
• Confusing syntax error with runtime error

5. Given this code, what will be the output?

module A
  def info
    "A" + super
  end
end

module B
  def info
    "B" + super
  end
end

class Base
  def info
    "Base"
  end
end

class MyClass < Base
  prepend A
  prepend B
end

puts MyClass.new.info

hard

A. "BABase"

B. "BaseAB"

C. "ABBase"

D. "BASuperBase"

Solution

1. Step 1: Understand multiple prepends order

   Modules prepended last are checked first, so B is before A in lookup.

2. Step 2: Trace method calls

   B#info runs first, returns "B" + super, which calls A#info, returning "A" + super, which calls Base#info returning "Base".

3. Step 3: Combine results

   Concatenate strings: "B" + "A" + "Base" = "BABase".

4. Final Answer:

   "BABase" -> Option A

5. Quick Check:

   Last prepend runs first; super chains down [OK]

Hint: Last prepended module runs first in method chain [OK]

Common Mistakes:

• Assuming first prepended module runs first
• Ignoring method lookup order with multiple prepends
• Confusing prepend with include order