Why modules solve multiple inheritance in Ruby - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of including modules in Ruby

What is the output of this Ruby code when calling obj.greet?

Ruby

module A
  def greet
    "Hello from A"
  end
end

module B
  def greet
    "Hello from B"
  end
end

class MyClass
  include A
  include B
end

obj = MyClass.new
puts obj.greet

A Hello from B

B Hello from A

C Hello from AHello from B

D NoMethodError

💡 Hint

Remember that the last included module's methods override earlier ones.

In Ruby, when multiple modules are included, the methods from the last included module take precedence. Here, module B is included after A, so its greet method overrides A's.

🧠 Conceptual

intermediate

Why Ruby uses modules instead of multiple inheritance

Why does Ruby use modules to solve the problem of multiple inheritance instead of allowing classes to inherit from multiple classes?

A Because modules allow sharing methods without the complexity of multiple class inheritance and avoid diamond problem issues.

B Because Ruby does not support inheritance at all.

C Because modules are faster to execute than classes.

D Because Ruby classes can only inherit from modules, not other classes.

💡 Hint

Think about method conflicts and complexity in multiple inheritance.

Ruby uses modules to share reusable code across classes without the complexity and ambiguity of multiple inheritance, such as the diamond problem. Modules provide a clean way to mix in behavior.

🔧 Debug

advanced

Identify the error in module inclusion

What error will this Ruby code produce and why?

Ruby

module M
  def hello
    "Hi"
  end
end

class C
  include M
  include M
end

c = C.new
puts c.hello

A NameError: undefined method 'hello'

B TypeError: wrong argument type Module (expected Class)

C No error, outputs "Hi"

D ArgumentError: duplicate include

💡 Hint

Including the same module twice is allowed but has no extra effect.

Including the same module multiple times does not cause an error in Ruby. The method is available and outputs "Hi".

❓ Predict Output

advanced

Method lookup order with modules and inheritance

What is the output of this Ruby code?

Ruby

module M1
  def speak
    "M1 speaks"
  end
end

module M2
  def speak
    "M2 speaks"
  end
end

class Parent
  def speak
    "Parent speaks"
  end
end

class Child < Parent
  include M1
  include M2
end

puts Child.new.speak

A Parent speaks

B M2 speaks

C M1 speaks

D NoMethodError

💡 Hint

Modules included last override earlier modules and superclass methods.

Ruby's method lookup checks the last included module first, then earlier modules, then superclass. Here, M2 is last included, so its speak method is called.

🧠 Conceptual

expert

How modules solve the diamond problem in Ruby

In multiple inheritance, the diamond problem occurs when a class inherits from two classes that both inherit from a common superclass. How do Ruby modules help avoid this problem?

A Ruby requires explicit method overrides to resolve diamond problem manually.

B Modules prevent inheritance entirely, so diamond problem cannot occur.

C Ruby duplicates methods from modules to each class, so no shared superclass exists.

D Modules are mixed in linearly, so Ruby uses a method lookup path that avoids ambiguity by checking modules in reverse inclusion order before superclass.

💡 Hint

Think about how Ruby searches for methods when modules are included.

Ruby solves the diamond problem by inserting modules into the inheritance chain in a linear order. The method lookup path checks included modules in reverse order of inclusion before moving to the superclass, avoiding ambiguity.