Module declaration syntax in Ruby - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the basic syntax to declare a module in Ruby?

Use the module keyword followed by the module name and end. For example:

module MyModule
  # code here
end

beginner

Can a Ruby module contain methods and constants?

Yes, a Ruby module can contain methods, constants, and even other modules or classes. It acts like a container for related code.

beginner

How do you define a method inside a Ruby module?

Inside the module block, define methods just like in a class using <code>def method_name</code>. For example:<br><pre>module Greetings
  def hello
    puts 'Hello!'
  end
end</pre>

intermediate

What is the purpose of using modules in Ruby?

Modules group related methods and constants together. They help organize code and can be mixed into classes to share behavior without inheritance.

intermediate

Is it possible to nest modules inside other modules in Ruby?

Yes, Ruby allows nesting modules inside other modules to create a hierarchy or namespace. For example:

module Outer
  module Inner
    # code
  end
end
end

Which keyword starts a module declaration in Ruby?

A package

B module

C def

D class

The module keyword is used to declare a module in Ruby.

What keyword ends a module declaration in Ruby?

A end

B stop

C close

D finish

Ruby uses end to close blocks including modules.

Can a Ruby module contain instance variables?

A Modules can have instance variables but they behave differently

B Yes, like classes

C Modules can have class variables but not instance variables

D No, modules cannot have any variables

Modules can have instance variables, but they belong to the module itself, not to instances like in classes.

How do you call a method defined inside a module without including it in a class?

A new module_name.method_name()

B method_name()

C module_name.method_name

D You cannot call it without including

You can call module methods directly using the module name if they are defined as module methods (e.g., with self.method_name).

What is a common use of modules in Ruby?

A To create objects

B To replace classes

C To store global variables

D To share reusable code across classes

Modules are often used to share reusable methods and constants across multiple classes.

Explain how to declare a module in Ruby and what it can contain.

Think about the structure and what you can put inside the module.

Describe why and how you would use modules in Ruby programming.

Consider how modules help avoid repeating code.

Practice

1. What is the correct way to declare a module named MathTools in Ruby?

easy

A. def MathTools
# code here
end

B. module MathTools
# code here
end

C. class MathTools
# code here
end

D. package MathTools {
# code here
}

Solution

1. Step 1: Recognize Ruby module syntax

   In Ruby, modules are declared using the keyword module followed by the module name and end.

2. Step 2: Identify the correct declaration

   module MathTools # code here end uses module MathTools ... end, which is the correct syntax for a module.

3. Final Answer:

   module MathTools # code here end -> Option B

4. Quick Check:

   Ruby modules use module Name ... end [OK]

Hint: Modules start with 'module' and end with 'end' [OK]

Common Mistakes:

• Using 'class' instead of 'module'
• Using 'def' which is for methods
• Using non-Ruby syntax like 'package'

2. Which of the following is a syntax error when declaring a module in Ruby?

easy

A. module Tools {
def help
end
}

B. module Tools
def self.help
end
end

C. module Tools
end

D. module Tools
CONSTANT = 10
end

Solution

1. Step 1: Check Ruby module block delimiters

   Ruby modules use module ... end without braces { }.

2. Step 2: Identify invalid syntax

   module Tools { def help end } uses braces { } which is invalid syntax for module declaration in Ruby.

3. Final Answer:

   module Tools { def help end } -> Option A

4. Quick Check:

   Ruby modules use 'module ... end', not braces [OK]

Hint: Ruby modules never use curly braces for blocks [OK]

Common Mistakes:

• Using curly braces instead of 'end'
• Missing 'end' keyword
• Confusing module with class syntax

3. What will be the output of the following Ruby code?

module Greetings
  def self.say_hello
    "Hello!"
  end
end

puts Greetings.say_hello

medium

A. Hello!

B. Greetings.say_hello

C. NoMethodError

D. SyntaxError

Solution

1. Step 1: Understand module method definition

   The method say_hello is defined as a module method using self., so it can be called on the module directly.

2. Step 2: Evaluate the method call output

   Calling Greetings.say_hello returns the string "Hello!", which is printed by puts.

3. Final Answer:

   Hello! -> Option A

4. Quick Check:

   Module method call returns string output [OK]

Hint: Module methods use self. and can be called directly [OK]

Common Mistakes:

• Trying to call method without self. prefix
• Expecting instance method behavior
• Confusing syntax errors with method calls

4. Identify the error in the following Ruby module declaration:

module Tools
  def help
    "Help message"
  end
end

Tools.help

medium

A. No error, code runs fine

B. Missing 'end' keyword for module

C. Method 'help' should be defined with 'self.' to call on module

D. Module name should be lowercase

Solution

1. Step 1: Check method definition inside module

   The method help is defined as an instance method, but called on the module directly.

2. Step 2: Understand method call context

   To call Tools.help, help must be a module method defined with self.help.

3. Final Answer:

   Method 'help' should be defined with 'self.' to call on module -> Option C

4. Quick Check:

   Module methods need 'self.' prefix to be called on module [OK]

Hint: Use 'def self.method' for module-level methods [OK]

Common Mistakes:

• Defining instance methods but calling on module
• Forgetting 'self.' prefix for module methods
• Assuming lowercase module names are valid

5. Given the following nested module declarations, which is the correct way to define a module Inner inside module Outer in Ruby?

module Outer
  # Your code here
end

hard

A. module Outer
class Inner
end
end

B. module Outer::Inner
end

C. module Outer.Inner
end

D. module Outer
module Inner
end
end

Solution

1. Step 1: Understand nested module syntax

   In Ruby, nested modules can be declared by placing one module inside another.

2. Step 2: Identify correct nested declaration

   module Outer module Inner end end correctly nests module Inner inside module Outer using indentation and end keywords.

3. Final Answer:

   module Outer module Inner end end -> Option D

4. Quick Check:

   Nested modules use nested 'module ... end' blocks [OK]

Hint: Nest modules by placing one inside another with 'module' [OK]

Common Mistakes:

• Using dot notation instead of :: for nested modules
• Using class instead of module for nested module
• Incorrect syntax like dot (.) in module names