Ruby prepend Method

last modified April 27, 2025

This tutorial explains how to use Ruby's prepend method. This powerful module inclusion method alters method lookup order in classes.

The prepend method inserts a module before the class in the ancestor chain. This means module methods override class methods with the same name. It's the opposite of include.

Prepending is useful for method overriding, decoration, and aspect-oriented programming. It allows clean separation of concerns while modifying behavior. Multiple prepends stack in reverse order.

Basic prepend Example

This simple example demonstrates how prepend changes method lookup order. The module method takes precedence over the class method.

basic_prepend.rb

module Greeter
  def greet
    "Hello from module!"
  end
end

class Person
  prepend Greeter
  
  def greet
    "Hello from class!"
  end
end

puts Person.new.greet

The output shows the module's method is called, not the class's. This happens because prepend puts Greeter before Person in the ancestor chain.

Multiple prepend Calls

When multiple modules are prepended, they are inserted in reverse order. The last prepended module appears first in the ancestor chain.

multiple_prepends.rb

module A
  def greet
    "A says: #{super}"
  end
end

module B
  def greet
    "B says: #{super}"
  end
end

class Person
  prepend A
  prepend B
  
  def greet
    "Hello!"
  end
end

puts Person.new.greet
puts Person.ancestors

The output shows B's method calls A's, which calls the original. The ancestors list shows B comes before A, which comes before Person.

prepend vs include

This example contrasts prepend with include. Include puts modules after the class in the ancestor chain, while prepend puts them before.

prepend_vs_include.rb

module M
  def greet
    "Module says: #{super}"
  end
end

class Included
  include M
  
  def greet
    "Class says hello!"
  end
end

class Prepended
  prepend M
  
  def greet
    "Class says hello!"
  end
end

puts "Include: #{Included.new.greet}"
puts "Prepend: #{Prepended.new.greet}"
puts "Included ancestors: #{Included.ancestors}"
puts "Prepended ancestors: #{Prepended.ancestors}"

With include, the class method wins. With prepend, the module method wins. The ancestors output shows the different method lookup orders.

Using super with prepend

The super keyword works naturally with prepend, allowing chained method calls. This enables powerful method decoration patterns.

super_with_prepend.rb

module Logging
  def save
    puts "Logging before save"
    super
    puts "Logging after save"
  end
end

class Document
  prepend Logging
  
  def save
    puts "Saving document..."
  end
end

Document.new.save

The Logging module wraps the original save method, adding behavior before and after. This is a common prepend use case for cross-cutting concerns.

prepend for Method Overriding

prepend can override methods from parent classes, not just the current class. This example shows overriding an inherited method.

override_inherited.rb

class Animal
  def speak
    "Animal sound"
  end
end

module Loud
  def speak
    "#{super.upcase}!!!"
  end
end

class Dog < Animal
  prepend Loud
  
  def speak
    "Woof"
  end
end

puts Dog.new.speak
puts Dog.ancestors

The Loud module overrides both Dog's speak and Animal's speak. The output shows the module's version is called first, which can then call super.

Dynamic prepend

prepend can be called at runtime, not just during class definition. This allows dynamic modification of behavior.

dynamic_prepend.rb

module AdminFeatures
  def access
    "Admin access granted"
  end
end

class User
  def access
    "Regular user access"
  end
end

user = User.new
puts user.access

User.prepend(AdminFeatures)
puts user.access

After prepending AdminFeatures, even existing instances get the new behavior. This demonstrates Ruby's dynamic nature and prepend's runtime effects.

prepend in Real-world Use

This example shows a practical use case for prepend - adding caching to an expensive calculation without modifying the original class.

caching_example.rb

module Cache
  def calculate
    @cache ||= {}
    @cache[inputs] ||= super
  end
  
  def inputs
    [@x, @y]
  end
end

class Calculator
  prepend Cache
  
  def initialize(x, y)
    @x = x
    @y = y
  end
  
  def calculate
    puts "Performing expensive calculation..."
    @x * @y
  end
end

calc = Calculator.new(5, 10)
puts calc.calculate
puts calc.calculate

The Cache module transparently adds memoization. The second calculate call returns the cached result without recalculating. The original Calculator remains unchanged.

Source

Ruby Module#prepend Documentation

This tutorial covered Ruby's prepend method with practical examples showing method overriding, decoration, and dynamic behavior modification.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Ruby tutorials.

Ebooks