Include for instance methods in Ruby - Time & Space Complexity

Time Complexity: Include for instance methods

O(n)

Understanding Time Complexity

When we use include to add instance methods from a module in Ruby, it affects how methods are found and run.

We want to know how the time to find and run these methods changes as the program grows.

Scenario Under Consideration

Analyze the time complexity of method calls when using include for instance methods.

module Greetings
  def hello
    "Hello!"
  end
end

class Person
  include Greetings

  def greet
    hello
  end
end

person = Person.new
person.greet
    

This code adds the hello method from the Greetings module to instances of Person using include.

Identify Repeating Operations

Look at what happens when greet calls hello:

• Primary operation: Ruby looks up the hello method in the method lookup path.
• How many times: Each time hello is called, Ruby searches the class and included modules.

How Execution Grows With Input

As you add more modules or methods, Ruby checks each place in order to find the method.

Input Size (number of modules/methods)	Approx. Operations
1	1 check
10	Up to 10 checks
100	Up to 100 checks

Pattern observation: The more modules included, the longer it takes to find the method, growing roughly in a straight line.

Final Time Complexity

Time Complexity: O(n)

This means the time to find an instance method grows linearly with the number of modules and classes Ruby must check.

Common Mistake

[X] Wrong: "Including a module makes method calls instant no matter how many modules there are."

[OK] Correct: Ruby must search through each included module in order, so more modules mean more work to find the method.

Interview Connect

Understanding how Ruby finds methods when using include helps you explain performance in real Ruby programs and shows you know how method lookup works behind the scenes.

Self-Check

"What if we used extend instead of include? How would the time complexity of method lookup change?"