Comparable module usage in Ruby - Step-by-Step Execution

Concept Flow - Comparable module usage

Define class with <=> method

↓

Include Comparable module

↓

Create objects

↓

Use comparison operators (>, <, ==, etc.)

↓

Ruby calls <=> method internally

↓

Return true/false based on <=> result

↓

Comparison result used in code

The class defines a <=> method and includes Comparable. Ruby uses <=> to compare objects with operators like >, <, ==.

Execution Sample

Ruby

class Box
  include Comparable
  attr_reader :volume
  def initialize(volume)
    @volume = volume
  end
  def <=>(other)
    volume <=> other.volume
  end
end
b1 = Box.new(10)
b2 = Box.new(20)
p b1 < b2

This code compares two Box objects by their volume using Comparable.

Execution Table

Step	Action	Evaluation	Result
1	Create b1 with volume 10	b1.volume = 10	b1 object created
2	Create b2 with volume 20	b2.volume = 20	b2 object created
3	Compare b1 < b2	Calls b1.<=>(b2)	10 <=> 20 returns -1
4	Interpret <=> result	-1 means b1 < b2 is true	Comparison returns true
5	Print result	p true	true printed

💡 Comparison completes after <=> returns -1, so b1 < b2 is true

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
b1.volume	undefined	10	10	10	10
b2.volume	undefined	undefined	20	20	20
comparison_result	undefined	undefined	undefined	-1	-1

Key Moments - 3 Insights

Why does Ruby use the <=> method when we write b1 < b2?

Ruby calls the <=> method internally to decide the result of <, >, == operators as shown in execution_table step 3.

What happens if the <=> method returns nil?

If <=> returns nil, Ruby cannot compare objects and raises an error or returns false for comparisons, because nil means no comparison possible.

Why do we include Comparable module in the class?

Including Comparable gives us all comparison operators automatically, but it requires defining <=> method to work, as shown in concept_flow.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of comparison_result after step 3?

A 1

B -1

C 0

D nil

💡 Hint

Check the 'Evaluation' and 'Result' columns in step 3 of execution_table.

At which step does Ruby decide the comparison b1 < b2 is true?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Interpret <=> result' action in execution_table step 4.

If the <=> method returned 0, what would be the result of b1 < b2?

A false

B true

C nil

D error

💡 Hint

Recall that 0 means objects are equal, so b1 < b2 would be false.

Concept Snapshot

Define <=> method in your class
Include Comparable module
Use <, >, == operators on objects
Ruby calls <=> internally
Return -1, 0, 1 from <=> for comparison
Nil means no comparison possible

Full Transcript

This example shows how to use the Comparable module in Ruby. First, you define a class with a <=> method that compares two objects. Then you include the Comparable module to get comparison operators like < and >. When you compare two objects, Ruby calls the <=> method internally. The <=> method returns -1 if the first object is less, 0 if equal, and 1 if greater. This return value determines the result of the comparison operators. If <=> returns nil, Ruby cannot compare the objects. The execution table traces creating two Box objects with volumes 10 and 20, then comparing them with <. The comparison calls <=> which returns -1, so b1 < b2 is true. This visual helps understand how Comparable works step-by-step.

Practice

1.

What is the main purpose of including the Comparable module in a Ruby class?

easy

A. To allow the class to inherit from another class

B. To automatically generate getter and setter methods

C. To enable comparison operators like <, <=, ==, >, >= for objects of that class

D. To add string manipulation methods to the class

Solution

1. Step 1: Understand Comparable module purpose

   The Comparable module provides comparison operators such as <, <=, ==, >, >= for objects.

2. Step 2: Recognize what including Comparable does

   Including Comparable requires defining the <=> method and then gives the class comparison operators automatically.

3. Final Answer:

   To enable comparison operators like <, <=, ==, >, >= for objects of that class -> Option C

4. Quick Check:

   Comparable adds comparison operators = A [OK]

Hint: Comparable adds comparison operators if <=> is defined [OK]

Common Mistakes:

• Thinking Comparable adds getters/setters
• Confusing Comparable with inheritance
• Assuming Comparable adds unrelated methods

2.

Which of the following is the correct way to define the comparison method <=> inside a Ruby class to use with Comparable?

class Box
  include Comparable

  def initialize(volume)
    @volume = volume
  end

  def <=>(other)
    ?
  end
end

easy

A. @volume <=> other.instance_variable_get(:@volume)

B. self.volume <=> other.volume

C. @volume <=> other.volume

D. @volume <=> other.@volume

Solution

1. Step 1: Understand instance variable access

   The instance variable @volume is private, so to compare, we must access it properly.

2. Step 2: Check each option for syntax and correctness

   self.volume <=> other.volume uses self.volume but no getter method is defined, so it fails. @volume <=> other.volume tries other.volume but no method exists. @volume <=> other.instance_variable_get(:@volume) uses other.instance_variable_get(:@volume), which accesses the variable correctly. @volume <=> other.@volume uses invalid syntax other.@volume.

3. Final Answer:

   @volume <=> other.instance_variable_get(:@volume) -> Option A

4. Quick Check:

   Access private var with instance_variable_get = B [OK]

Hint: Use instance_variable_get to access private vars in <=> [OK]

Common Mistakes:

• Trying to access other.@volume directly (syntax error)
• Assuming getter methods exist without defining them
• Using self.volume without a method

3.

What will be the output of the following Ruby code?

class Person
  include Comparable

  attr_reader :age

  def initialize(age)
    @age = age
  end

  def <=>(other)
    age <=> other.age
  end
end

p1 = Person.new(30)
p2 = Person.new(25)
puts p1 > p2

medium

A. false

B. true

C. nil

D. Error

Solution

1. Step 1: Understand the <=> method

   The <=> method compares the ages of two Person objects using age <=> other.age.

2. Step 2: Compare p1 and p2 using >

   p1.age is 30, p2.age is 25, so 30 > 25 is true.

3. Final Answer:

   true -> Option B

4. Quick Check:

   30 > 25 = true [OK]

Hint: Compare attributes inside <=> for correct operator results [OK]

Common Mistakes:

• Forgetting to include Comparable
• Not defining <=> method
• Confusing attribute names

4.

Identify the error in this Ruby class using Comparable and how to fix it:

class Item
  include Comparable

  def initialize(weight)
    @weight = weight
  end

  def <=>(other)
    @weight - other.weight
  end
end

medium

A. Method <=> returns a number, should return -1, 0, or 1

B. Syntax error in method definition spacing

C. Missing include Comparable line

D. Cannot call other.weight because no weight method is defined

Solution

1. Step 1: Check method calls inside <=>

   The code calls other.weight, but no weight method is defined in the class.

2. Step 2: Fix by adding an attr_reader for weight

   Adding attr_reader :weight allows other.weight to work correctly.

3. Final Answer:

   Cannot call other.weight because no weight method is defined -> Option D

4. Quick Check:

   Missing getter method = D [OK]

Hint: Define attr_reader for accessed attributes in <=> [OK]

Common Mistakes:

• Assuming instance variables are accessible without getters
• Returning subtraction result instead of using <=> operator
• Ignoring spacing in method definition (which is valid)

5.

You want to sort an array of Product objects by their price using Comparable. Which of the following is the best way to implement the <=> method?

class Product
  include Comparable

  attr_reader :price

  def initialize(price)
    @price = price
  end

  def <=>(other)
    ?
  end
end

hard

A. price <=> other.price

B. other.price <=> price

C. price - other.price

D. price > other.price ? 1 : -1

Solution

1. Step 1: Understand the <=> method contract

   The <=> method should return -1, 0, or 1 depending on comparison.

2. Step 2: Choose the correct comparison expression

   Using price <=> other.price correctly returns -1, 0, or 1. other.price <=> price reverses order, sorting descending. price - other.price returns a number but not guaranteed -1,0,1. price > other.price ? 1 : -1 returns only 1 or -1, missing 0 case.

3. Final Answer:

   price <=> other.price -> Option A

4. Quick Check:

   Use <=> operator for proper comparison = C [OK]

Hint: Use <=> operator directly for clean comparison [OK]

Common Mistakes:

• Reversing comparison order unintentionally
• Returning subtraction result instead of <=>
• Using ternary without zero equality case