What are modules in Ruby? How do they enhance code reusability and organization?

In Ruby, modules are containers for organizing and grouping related methods, constants, and other module definitions. They provide a way to achieve code reusability and maintainability by encapsulating functionality into separate units.

Modules act as mixins, allowing classes to incorporate their behavior using the `include` keyword. This concept is known as mixin inheritance, and it enables multiple classes to share common methods and constants defined within a module.

One of the primary benefits of using modules is code reusability. By defining common functionality in a module, you can include that module in multiple classes, allowing them to access and utilize the methods defined within it. This promotes the DRY (Don't Repeat Yourself) principle and reduces code duplication. Instead of writing the same code in multiple classes, you can define it once in a module and include that module wherever it's needed.

Modules also help in organizing code. They provide a way to logically group related methods and constants, making the codebase more modular and easier to understand. By separating concerns into modules, you can achieve better code organization and maintainability. Each module can focus on a specific aspect of functionality, improving the overall structure of your code.

Here's an example to illustrate the use of modules in Ruby:

```
ruby`module MathFunctions
def self.square(number)
number * number
end

def self.cube(number)
number * number * number
end
end

class Calculator
include MathFunctions

def calculate\_square\_and\_cube(number)
square_result = MathFunctions.square(number)
cube_result = MathFunctions.cube(number)
puts "Square: #{square\_result}, Cube: #{cube\_result}"
end
end

calculator = Calculator.new
calculator.calculate_square_and_cube(5)`
```
In the above code, we define a module called `MathFunctions` that contains the `square` and `cube` methods. These methods perform mathematical operations on a given number. The `Calculator` class includes the `MathFunctions` module using the `include` keyword, allowing the calculator object to access the methods defined in the module. The `calculate_square_and_cube` method then calls the `square` and `cube` methods from the `MathFunctions` module to calculate the square and cube of a given number.

By using modules, we have encapsulated the mathematical operations into a separate unit (`MathFunctions` module) and included it in the `Calculator` class. This approach enhances code reusability, as the same module can be included in other classes that require similar mathematical functionality. It also improves code organization, as the mathematical operations are grouped within the `MathFunctions` module, making the codebase more modular and easier to navigate.

In summary, modules in Ruby are powerful tools for achieving code reusability and organization. They allow you to encapsulate related functionality into separate units and include them in classes as mixins. By using modules, you can write reusable code, avoid duplication, and organize your codebase in a logical and modular manner.