Modules are containers for methods and constants that can't be instantiated. Their key use is as mixins — sharing methods across classes via include (since Ruby has single inheritance). Modules also provide namespacing. Mixins are Ruby's elegant alternative to multiple inheritance.
()
puts
() = = name
.new().greet
Since Ruby has single inheritance, modules solve code reuse across unrelated classes: a module defines methods, and any class can include it to gain those methods. A class can include many modules — Ruby's answer to multiple inheritance.
module Helper
def help; "helping"; end
end
class A
include Helper # adds as INSTANCE methods → A.new.help
end
class B
extend Helper # adds as CLASS methods → B.help
end
include adds the module's methods as instance methods; extend adds them as class methods.
module Payments
class Processor; end # fully qualified: Payments::Processor
TAX_RATE = 0.08
end
Payments::Processor.new # access via the namespace — avoids name collisions
Modules also serve as namespaces, grouping related classes/constants under a name (Payments::Processor) to prevent collisions.
class Temperature
include Comparable # mixing in Comparable gives <, >, ==, between?, etc.
attr_reader :degrees
def <=>(other) # just define <=> ...
degrees <=> other.degrees
end # ...and Comparable provides all comparison methods!
end
Ruby's built-in mixins (Comparable, Enumerable) are powerful: implement one method (<=> or each) and the module provides many more (comparisons, or map/select/etc.).
Modules and mixins are important, distinctive Ruby features central to how Ruby achieves code reuse and organization, so understanding them is essential for idiomatic Ruby.
Since Ruby has single inheritance, mixins (including modules into classes via include) are Ruby's elegant solution for sharing behavior across unrelated classes — a class can include multiple modules to gain their methods, providing the benefits of multiple inheritance without its problems.
This is fundamental to how Ruby code (and Rails) is structured: cross-cutting behavior is packaged in modules and mixed into classes that need it.
Understanding include (instance methods) vs extend (class methods), modules as namespaces (grouping related code to avoid collisions), and especially Ruby's powerful built-in mixins (Comparable and Enumerable — where implementing one method like <=> or each gives you many methods for free) is important for both writing reusable Ruby and understanding the framework code you use.
Modules/mixins are how Ruby composes behavior elegantly, and they appear throughout the standard library and frameworks.
Mastering them — mixins for code sharing (Ruby's multiple-inheritance alternative), include vs extend, namespacing, and leveraging Comparable/Enumerable — is important, frequently-applied knowledge that reflects understanding of Ruby's compositional design and is essential for writing idiomatic, reusable Ruby and a common interview topic.