Why operators are methods in Ruby - Visual Breakdown

Concept Flow - Why operators are methods in Ruby

Start with an expression

↓

Ruby sees operator

↓

Treat operator as method call

↓

Call method on object

↓

Method executes and returns result

↓

Use result in expression

Ruby treats operators like +, -, * as method calls on objects, so operators are just methods that can be customized.

Execution Sample

Ruby

a = 5
b = 3
result = a + b
puts result

Adds two numbers by calling the + method on object a with b as argument, then prints the result.

Execution Table

Step	Action	Evaluation	Result
1	Assign 5 to a	a = 5	a is 5
2	Assign 3 to b	b = 3	b is 3
3	Evaluate a + b	Call a.+(b)	5 + 3 = 8
4	Assign result	result = 8	result is 8
5	Print result	puts 8	Output: 8

💡 Program ends after printing the result

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	Final
a	nil	5	5	5	5	5
b	nil	nil	3	3	3	3
result	nil	nil	nil	nil	8	8

Key Moments - 3 Insights

Why does Ruby treat + as a method instead of a special symbol?

Because in Ruby, operators like + are actually method calls on objects (see step 3 in execution_table), allowing customization by redefining these methods.

How does Ruby know which method to call for an operator?

Ruby calls the method named after the operator on the left object (a.+(b) in step 3), so the method belongs to the object's class.

Can operators behave differently for different objects?

Yes, since operators are methods, different classes can define their own versions, changing how operators work (like + for numbers vs strings).

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'result' after step 4?

A 3

B 5

C 8

D nil

💡 Hint

Check the 'result' variable value in the variable_tracker after step 4

At which step does Ruby treat the + operator as a method call?

A Step 3

B Step 1

C Step 5

D Step 2

💡 Hint

Look at the 'Action' column in execution_table where a.+(b) is called

If we changed 'a' to a string '5', how would the operator + behave?

A It would add numbers as before

B It would concatenate strings

C It would cause an error

D It would subtract values

💡 Hint

String#+ expects a String argument, so if b is also a string, it concatenates; otherwise, it causes a TypeError

Concept Snapshot

In Ruby, operators like +, -, * are methods called on objects.
Example: a + b is a.+(b).
This lets classes customize operator behavior.
Operators are not special symbols but regular methods.
This design makes Ruby flexible and consistent.

Full Transcript

Ruby treats operators such as + as methods on objects. When Ruby sees an expression like a + b, it actually calls the method + on object a with b as the argument. This means operators are just normal methods that can be redefined or customized by classes. For example, numbers have a + method that adds values, while strings have a + method that joins text. This approach makes Ruby flexible and consistent because all operations are method calls. The execution trace shows assigning values to variables a and b, then calling a.+(b) to add them, storing the result, and printing it.