Custom modules as mixins in Ruby - Step-by-Step Execution

Concept Flow - Custom modules as mixins

Define Module with Methods

↓

Define Class

↓

Include Module in Class

↓

Create Object of Class

↓

Call Module Methods on Object

↓

Methods from Module Run as if in Class

This flow shows how a module with methods is defined and then included in a class to add those methods to the class's objects.

Execution Sample

Ruby

module Greetable
  def greet
    "Hello!"
  end
end

class Person
  include Greetable
end

p = Person.new
puts p.greet

This code defines a module with a greet method, includes it in a class, creates an object, and calls the greet method from the module.

Execution Table

Step	Action	Evaluation	Result
1	Define module Greetable with method greet	Module Greetable created	Greetable module ready with greet method
2	Define class Person	Class Person created	Person class ready
3	Include Greetable in Person	Greetable methods added to Person	Person now has greet method
4	Create object p = Person.new	New Person object created	p is a Person object
5	Call p.greet	Calls greet method from Greetable	"Hello!" printed
6	Program ends	No more code	Execution stops

💡 Program ends after printing "Hello!" from the greet method

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
p	undefined	Person object created	Person object exists	Person object exists

Key Moments - 2 Insights

Why can p.greet be called even though greet is not defined in Person?

Because the module Greetable was included in Person, its methods become available to Person's objects, as shown in step 3 and 5 of the execution_table.

Does including a module copy methods into the class?

No, including a module mixes in the methods so they behave as if defined in the class, without copying. This is why p.greet works as in step 5.

Visual Quiz - 3 Questions

Look at the execution_table, what is the result of calling p.greet at step 5?

A Nothing happens

B "Hello!" is printed

C Error: greet method not found

D "Goodbye!" is printed

💡 Hint

Check step 5 in execution_table where p.greet is called and "Hello!" is printed

At which step does the Person class gain the greet method?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look at step 3 where Greetable is included in Person, adding greet method

If we remove 'include Greetable' from Person, what happens when calling p.greet?

A It raises an error: undefined method greet

B It prints "Hello!"

C It prints nil

D It prints an empty string

💡 Hint

Without including the module (step 3), Person does not have greet method, so calling p.greet fails

Concept Snapshot

Custom modules as mixins in Ruby:
- Define a module with methods.
- Include the module in a class using 'include'.
- Objects of the class can call module methods as if defined in the class.
- This allows sharing behavior without inheritance.
- Methods are mixed in, not copied.

Full Transcript

This visual execution shows how Ruby modules can be used as mixins. First, a module named Greetable is defined with a method greet that returns "Hello!". Then, a class Person is defined. The module Greetable is included in Person, which means Person now has the greet method. When we create an object p of Person and call p.greet, it runs the greet method from the module and prints "Hello!". The execution table traces each step from defining the module and class, including the module, creating the object, and calling the method. The variable tracker shows the object p being created and used. Key moments clarify why p.greet works even though greet is not directly defined in Person. The quizzes test understanding of when methods become available and what happens if the module is not included. This helps beginners see how mixins add reusable behavior to classes in Ruby.