Method chaining patterns in Ruby - Step-by-Step Execution

Concept Flow - Method chaining patterns

Start with object

↓

Call method1

↓

method1 returns self or new object

↓

Call method2 on returned object

↓

method2 returns self or new object

↓

Call method3 on returned object

↓

Final result or object returned

Method chaining calls multiple methods one after another on the same object or returned objects, each returning self or a new object to continue the chain.

Execution Sample

Ruby

class Chain
  def initialize(val)
    @val = val
  end
  def add(x)
    @val += x
    self
  end
  def multiply(x)
    @val *= x
    self
  end
  def result
    @val
  end
end

c = Chain.new(2).add(3).multiply(4).result

This code creates a Chain object, adds 3, multiplies by 4, then gets the result using method chaining.

Execution Table

Step	Action	Object State (@val)	Return Value	Chain Progress
1	Chain.new(2)	2	Chain object with @val=2	Start object created
2	add(3)	5	self (Chain object with @val=5)	Continue chaining
3	multiply(4)	20	self (Chain object with @val=20)	Continue chaining
4	result	20	20 (final value)	Chain ends with value

💡 All methods return self except result which returns the final value, ending the chain.

Variable Tracker

Variable	Start	After add(3)	After multiply(4)	Final
@val	2	5	20	20
c	Chain object @val=2	Chain object @val=5	Chain object @val=20	Chain object @val=20

Key Moments - 3 Insights

Why do methods like add and multiply return self instead of a value?

Returning self allows the next method to be called on the same object, enabling chaining as shown in execution_table rows 2 and 3.

What happens if a method in the chain does not return self?

The chain breaks because the next method is called on the returned value, which may not be the expected object. See exit_note explaining chain ends when result returns a value.

How does the final result method differ from other methods in the chain?

The final method returns a value (like a number) instead of self, ending the chain and providing the output, as shown in execution_table row 4.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of @val after step 2?

A 5

B 2

C 20

D 3

💡 Hint

Check the 'Object State (@val)' column at step 2 in the execution_table.

At which step does the method chain end?

A Step 2

B Step 3

C Step 4

D Step 1

💡 Hint

Look at the 'Chain Progress' column to see when the chain ends with a final value.

If multiply method returned a number instead of self, what would happen at step 3?

A Chain would continue normally

B Chain would break and next method calls would fail

C The value of @val would reset to 0

D The object would be duplicated

💡 Hint

Refer to key_moments about why methods must return self to continue chaining.

Concept Snapshot

Method chaining calls multiple methods in a row on the same object.
Each method returns self or a new object to allow chaining.
Final method usually returns a value to end the chain.
Common in Ruby for clean, readable code.
Example: obj.method1.method2.method3
Use self return to keep chaining going.

Full Transcript

Method chaining in Ruby means calling several methods one after another on the same object. Each method returns self or a new object so the next method can be called immediately. In the example, we create a Chain object with value 2. Then add(3) changes the value to 5 and returns self. Next multiply(4) changes value to 20 and returns self. Finally, result returns the value 20, ending the chain. Returning self is key to keep chaining working. If a method returns something else, the chain breaks. This pattern makes code clean and easy to read by linking method calls together.