Modules and Mixins
A module, defined with the module keyword, is a collection of methods, constants, and other modules/classes that -- unlike a class -- cannot be instantiated with .new and cannot be subclassed. Modules serve two main purposes in Ruby: acting as namespaces to group related classes and constants together (avoiding naming collisions), and acting as mixins -- reusable bundles of behavior that get 'mixed into' a class's ancestor chain, giving Ruby much of the power of multiple inheritance without its complications.
Cricket analogy: A module acting as a mixin is like a fielding-drills playbook that any team can adopt without that playbook itself ever fielding a match, giving multiple squads shared techniques without one team subclassing another.
include, extend, and prepend
include mixes a module's methods in as instance methods of the including class, inserting the module into the ancestor chain directly above the class itself. extend mixes a module's methods in as singleton (class-level or object-level) methods instead. prepend also inserts the module into the instance method lookup chain, but ahead of the class itself, meaning the module's methods take priority over the class's own definitions -- useful for wrapping or decorating existing behavior while still being able to call super to reach the original method.
Cricket analogy: include adding a module's methods to the ancestor chain is like a franchise adopting a shared bowling-technique manual directly into its coaching hierarchy, while prepend is like a specialist consultant whose advice overrides the head coach's own calls first, letting the coach's original method still be reached via super.
module Loggable
def log(message)
puts "[#{self.class}] #{message}"
end
end
module Auditable
def save
puts "auditing before save"
super
end
end
class Order
include Loggable
prepend Auditable
def save
puts "saving order"
end
end
Order.new.log("created") # => "[Order] created"
Order.new.save
# => "auditing before save"
# => "saving order"Modules as namespaces
Wrapping related classes inside a module creates a namespace, preventing name collisions between similarly named classes in different parts of a large application -- a pattern used heavily by gems and Rails engines. You reference a namespaced constant with the :: scope resolution operator, e.g. Payments::CreditCard versus a hypothetical unrelated Shipping::CreditCard.
Cricket analogy: Namespacing classes inside a module is like two different leagues both having a team called 'Strikers' without confusion, since you always refer to them fully as IPL::Strikers versus BBL::Strikers.
module Payments
class CreditCard
def charge(amount)
"Charged $#{amount} via Payments::CreditCard"
end
end
end
Payments::CreditCard.new.charge(50)Enumerable and Comparable: mixins in the standard library
Ruby's own standard library relies heavily on the mixin pattern: including Comparable in a class and defining a single <=> (spaceship) method automatically grants that class <, >, ==, between?, and clamp. Including Enumerable and defining a single each method automatically grants dozens of methods like map, select, sort, reduce, and include?. This is the clearest real-world demonstration of why mixins are powerful: a tiny amount of code in your class unlocks a large, well-tested behavior surface from the module.
Cricket analogy: Including Comparable and defining <=> to unlock <, >, between? is like a selector defining one ranking formula and instantly being able to compare, rank, and shortlist any two players without writing separate comparison logic for each stat.
class TemperatureReading
include Comparable
attr_reader :celsius
def initialize(celsius)
@celsius = celsius
end
def <=>(other)
celsius <=> other.celsius
end
end
TemperatureReading.new(10) < TemperatureReading.new(20) # => trueBecause include inserts a module directly above the including class in the ancestor chain, a class's own method definitions still take priority over an included module's same-named method. prepend flips this priority so the module's method runs first (and can call super to delegate to the class's original method) -- a distinction that trips up many developers new to Ruby's mixin system.
Because Ruby resolves methods by walking the ancestor chain and stopping at the first match, including two modules that define a method with the same name means only the more recently included one 'wins' silently -- there's no compiler error warning you about the conflict, so name collisions between mixins can cause confusing bugs that only surface at runtime.
- Modules group methods/constants as namespaces and/or provide reusable behavior as mixins; they cannot be instantiated.
includeadds a module's methods as instance methods, inserted into the ancestor chain just above the including class.extendadds a module's methods as methods on the class/object itself rather than on instances.prependinserts a module ahead of the class in the lookup chain, letting it intercept and callsuperto reach the class's own method.- Including Comparable (with
<=>) or Enumerable (witheach) unlocks many standard methods from a minimal implementation. - Conflicting method names between multiple included modules resolve silently by ancestor-chain order, with no warning.
Practice what you learned
1. Where does `include SomeModule` insert the module in a class's ancestor chain?
2. What is the key difference between `include` and `prepend`?
3. What must a class define to gain sort, map, select, and reduce by including Enumerable?
4. What must a class define to gain <, >, and between? by including Comparable?
5. What happens when two included modules define a method with the same name?
Was this page helpful?
You May Also Like
Inheritance in Ruby
See how Ruby classes extend one another with single inheritance, how `super` calls parent implementations, and how method resolution order determines which method runs.
Classes and Objects in Ruby
Learn how Ruby defines classes as blueprints for objects, covering the `class` keyword, `initialize`, instance methods, and how everything in Ruby is an object.
Comparable and Enumerable Modules
See how Ruby's Comparable and Enumerable modules let a class gain dozens of methods for free by implementing just one core method each: `<=>` or `each`.
Method Visibility
Learn how Ruby's public, private, and protected keywords control which parts of an object's interface callers can access, and why visibility shapes good API design.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics