> For the complete documentation index, see [llms.txt](https://hunter-ducharme.gitbook.io/ruby-programming/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://hunter-ducharme.gitbook.io/ruby-programming/modules.md).

# Modules

## General Syntax:

A module is like a toolbox that contains a set of methods and constants. Modules are very much like classes, except they can’t create instances and can’t have subclasses. They’re just a way to store things that you might use later. It doesn’t make much sense to store variables in a module, for by definition, variables change or vary. Constants however, should always stay the same, so including helpful constants inside a module is a good idea. Ruby constants are written in ALL\_CAPS. So whenever you are creating a constant, it should be formatted accordingly.

## Creating a Module:

Creating a module is almost identical to creating a class. Like class names, module names are written in CapitalizedCamelCase as well.

It looks like this:

```ruby
module ModuleName
    # Insert methods and constants to use later
end
```

## Name-spacing & Scope Operators:

One of the main purposes of a module is to separate methods and constants into named spaces. This is called (conveniently), namespacing, and it’s how Ruby doesn’t confuse `Math::PI` and `Circle::PI`. The double colon in the previous example is called a scope resolution operator. It is just a way to tell ruby where you are looking for a specific piece of code. If you say `Math::PI`, then it tells Ruby to look inside the `Math` module and search for `PI`, and not any other `PI` such as in the module `Circle`.

## Importing External Modules:

Some modules, like `MATH`, are already present in the interpreter. However, sometimes you will need to be explicitly imported. We can do this using the require keyword. Like so: `require ‘module’`. We can do more than just require a module, we can also `include` it. Any class that includes a certain module can use that module’s methods and constants. You use include like so: `include Math`. Notice how it doesn’t use the quotes to call on the module. Also, whenever you include a module inside a class, that class no longer has to use the scope resolution operator (`::`) to define the module to look inside. Instead of writing `Math::PI`, you can just write `PI`.

## Modules & Classes:

Whenever a module is used to mix additional information and behavior into a class, it is called a mixin. Mixins allow us to customize a class without having to write additional code.

Example:

```ruby
module Action
    def jump
        @distance = rand(4) + 2
        puts "I jumped forward #{@distance} feet!"
    end
end

class Rabbit
    include Action
    attr_reader :name

    def initialize(name)
        @name = name
    end
end

class Cricket
    include Action
    attr_reader :name

    def initialize(name)
        @name = name
    end
end

peter = Rabbit.new("Peter")
jiminy = Cricket.new("Jiminy")

peter.jump
jiminy.jump
```

Notice how we define the `jump` method inside the `Action` module, the we `include` it into the `Rabbit` and `Cricket` class.

## Extending Include:

The `include` keyword only mixes in that module's methods and information at the instance level, to where only instances of that particular class can use the information. However, the `extend` keyword mixes the modules methods into the class level. This means the class itself can use that module’s information, as opposed to just instances of that class.

For example:

```ruby
module ThePresent
    def now
        puts "It's #{Time.new.hour > 12 ? Time.new.hour - 12 : Time.new.hour}:#{Time.new.min} #{Time.new.hour > 12 ? 'PM' : 'AM'} (GMT)."
    end
end

class TheHereAnd
    extend ThePresent
end

TheHereAnd.now
```

Notice how we `extend`ed the `now` method from `ThePresent` module into `TheHereAnd` class. This now allows the class to use the `ThePresent` module. Unlike before, where only instances of `TheHereAnd` class would have been able to use it.