Method lookup chain in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Method lookup with modules and classes

What is the output of this Ruby code?

Ruby

module A
  def greet
    "Hello from A"
  end
end

module B
  def greet
    "Hello from B"
  end
end

class C
  include A
  include B
end

puts C.new.greet

A Hello from B

B Hello from A

C NoMethodError

D Hello from C

💡 Hint

Remember that the last included module takes precedence in Ruby's method lookup chain.

In Ruby, when multiple modules are included, the last included module is checked first for methods. Here, module B is included after A, so greet from B is called.

🧠 Conceptual

intermediate

Understanding method lookup order with inheritance and modules

Given a class that inherits from a superclass and includes a module, which order does Ruby follow to find a method?

A 1, 2, 3, 4

B 1, 3, 2, 4

C 2, 1, 3, 4

D 3, 4, 1, 2

💡 Hint

Think about where Ruby looks first: the class, then modules included in it, then the superclass and its modules.

Ruby first looks in the class itself, then in the modules included in that class (checking the last included module first), then in the superclass, and finally in the modules included in the superclass.

❓ Predict Output

advanced

Method lookup with prepend and include

What will this Ruby code print?

Ruby

module M
  def hello
    "Hello from M"
  end
end

class X
  include M
  def hello
    "Hello from X"
  end
end

class Y < X
  prepend M
end

puts Y.new.hello

A Hello from Y

B Hello from X

C Hello from M

D NoMethodError

💡 Hint

Remember that prepend puts the module before the class in the lookup chain.

Using prepend inserts the module before the class in the method lookup chain. So hello from module M is called before the class X's method.

❓ Predict Output

advanced

Method lookup with super and modules

What is the output of this Ruby code?

Ruby

module M
  def foo
    "foo from M"
  end
end

class A
  include M
end

class B < A
  def foo
    super + " and foo from B"
  end
end

obj = B.new
puts obj.foo

A " and foo from B"

B "foo from M"

C NoMethodError

D "foo from M and foo from B"

💡 Hint

Remember that super starts method lookup from the superclass and follows its full ancestor chain, including modules included there.

foo is defined in module M, included in A. When B#foo calls super, lookup starts at A, which has no foo directly but includes M, so M#foo is found and executed, returning "foo from M". This is concatenated with " and foo from B".

❓ Predict Output

expert

Complex method lookup with multiple modules and prepend

What is the output of this Ruby code?

Ruby

module M1
  def call
    "M1"
  end
end

module M2
  def call
    "M2"
  end
end

class Base
  def call
    "Base"
  end
end

class Derived < Base
  include M1
  prepend M2
end

puts Derived.new.call

A M1

B M2

C Base

D NoMethodError

💡 Hint

Prepend modules come before the class in lookup order, even if the class includes other modules.

Prepending M2 places it before Derived in the lookup chain, so call from M2 is found first. Included modules like M1 come after the class itself.