Prepend for method chain insertion in Ruby - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the prepend method do in Ruby?

It inserts a module before the current class in the method lookup chain, so methods in the prepended module override the class's own methods.

intermediate

How is prepend different from include in Ruby?

<code>include</code> adds a module after the class in the method lookup chain, so class methods override module methods. <code>prepend</code> adds the module before the class, so module methods override class methods.

intermediate

Why use prepend for method chain insertion?

Because it lets you insert behavior before existing methods without changing the original class, enabling method wrapping or overriding cleanly.

beginner

Given this code:<br><pre>module M
  def greet
    "Hello from M"
  end
end

class C
  def greet
    "Hello from C"
  end
end

c = C.new
puts c.greet</pre><br>What will <code>c.greet</code> print after <code>C.prepend(M)</code>?

It will print "Hello from M" because prepend puts module M before class C in the method lookup chain.

intermediate

How can you call the original method from a prepended module's method?

Use <code>super</code> inside the prepended module's method to call the original method defined in the class or other modules further down the chain.

What happens when you use prepend with a module in Ruby?

A The class's methods override the module's methods.

B The module's methods are ignored.

C The module's methods override the class's methods.

D The module is added after the class in the lookup chain.

prepend inserts the module before the class in the method lookup chain, so the module's methods override the class's methods.

Which keyword lets you call the original method from inside a prepended module's method?

A base

B this

C self

D super

super calls the next method in the lookup chain, allowing access to the original method.

If a module is included instead of prepended, which methods take precedence?

A Class methods override module methods.

B Module methods and class methods have equal precedence.

C Module methods override class methods.

D Neither methods are called.

include adds the module after the class, so class methods override module methods.

Why might you use prepend instead of reopening a class to override a method?

A Because <code>prepend</code> is slower.

B To avoid changing the original class directly and keep code modular.

C Because <code>prepend</code> disables method overriding.

D To remove methods from the class.

prepend allows inserting behavior cleanly without modifying the original class code.

What will this code output?

module M
  def hello
    "Hi from M" + super
  end
end

class C
  def hello
    "Hi from C"
  end
end

C.prepend(M)
puts C.new.hello

A Hi from MHi from C

B Error

C Hi from M

D Hi from C

The prepended module's hello calls super, which calls the class's hello, so the output concatenates both strings.

Explain how prepend changes the method lookup chain in Ruby and why that is useful for method chain insertion.

Think about where the module sits compared to the class in the search for methods.

Describe how you can use super inside a prepended module's method to extend behavior rather than replace it.

How do you keep the original method's effect while adding new behavior?

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