Mastering Ruby’s Module System: Include vs. Extend

Ruby’s module system is a powerful tool for code organization and reusability. Two key methods, include and extend, allow you to incorporate module functionality into classes, but they do so in fundamentally different ways. This article clarifies their distinctions and guides you in choosing the appropriate method for your needs.

Table of Contents

• Understanding include in Ruby
• Understanding extend in Ruby
• When to Use include vs. extend
• Conclusion
• FAQ

Understanding include in Ruby

The include method brings a module’s methods into a class’s instances. Each object created from the class will inherit and be able to utilize these methods.

module Sayable
  def speak(message)
    puts message
  end
end

class Dog
  include Sayable
end

sparky = Dog.new
sparky.speak("Woof!") # => Woof!

In this example, Dog instances, like sparky, gain the speak method because of include.

Understanding extend in Ruby

extend, conversely, adds a module’s methods directly to the class itself, not its instances. These methods are callable on the class but not on individual objects created from that class.

module Growlable
  def growl
    puts "Grrrr!"
  end
end

class Cat
  extend Growlable
end

Cat.growl # => Grrrr!
whiskers = Cat.new
# whiskers.growl  # => NoMethodError: undefined method 'growl' for #<Cat:0x...>

Only the Cat class can call growl; whiskers, a Cat instance, cannot.

When to Use include vs. extend

The decision depends entirely on whether you need methods accessible at the instance level or the class level.

• Use include when: You’re adding methods that should be available to each object (instance) of the class. This is the most common use case. Think of adding behaviors or functionalities to individual objects.
• Use extend when: You’re adding methods that operate on the class itself, such as class-level methods (e.g., factory methods), or methods that modify class behavior. These methods typically don’t require access to instance variables.

Conclusion

include and extend are both valuable tools in Ruby’s arsenal. Understanding their distinct behaviors—instance-level versus class-level methods—is crucial for writing clean, maintainable, and efficient code. Choosing the right approach significantly impacts code design and readability.

FAQ

• Can I extend multiple modules? Yes, extending multiple modules adds their methods to the class.
• Can I include and extend the same module? Yes, providing both instance and class-level methods from that module.
• What happens if modules define methods with the same name? The last module included or extended wins; its method overrides the others (method overriding).
• Are there performance implications? Performance differences are usually negligible. Prioritize code design over minor performance optimizations.