Why functional patterns complement OOP in Ruby - See It in Action

Why functional patterns complement OOP

📖 Scenario: Imagine you are building a simple program to manage a list of tasks. You want to use Object-Oriented Programming (OOP) to organize your tasks as objects. But you also want to use functional programming patterns to process and transform your tasks easily and clearly.

🎯 Goal: You will create a list of tasks as objects, then use functional patterns like map and select to work with these tasks. This shows how functional programming complements OOP by making data processing simple and readable.

📋 What You'll Learn

Create a list of task objects with specific attributes

Add a configuration variable to filter tasks by priority

Use functional methods like map and select to process tasks

Print the filtered and transformed list of task names

💡 Why This Matters

🌍 Real World

Combining OOP and functional programming helps build clear and maintainable programs, like task managers or inventory systems.

💼 Career

Many software jobs require using OOP for structure and functional patterns for data processing, so this skill is very useful.

1

Create a list of task objects

Create a class called Task with attributes name and priority. Then create an array called tasks with these three tasks as Task objects: 'Wash dishes' with priority 2, 'Do homework' with priority 1, and 'Read book' with priority 3.

Ruby

# Define class Task with attributes name and priority
# Create array tasks with three Task objects

Hint

Define a class with attr_reader for attributes. Then create an array with new objects.

2

Add a priority filter variable

Create a variable called priority_threshold and set it to 2. This will be used to select tasks with priority less than or equal to this value.

Ruby

class Task
  attr_reader :name, :priority
  def initialize(name, priority)
    @name = name
    @priority = priority
  end
end

tasks = [
  Task.new('Wash dishes', 2),
  Task.new('Do homework', 1),
  Task.new('Read book', 3)
]

# Create priority_threshold variable and set to 2

Hint

Just create a variable and assign the number 2.

3

Filter and transform tasks using functional methods

Use select on tasks to get only tasks with priority less than or equal to priority_threshold. Then use map to get an array of task names from the filtered tasks. Store this result in a variable called filtered_task_names.

Ruby

class Task
  attr_reader :name, :priority
  def initialize(name, priority)
    @name = name
    @priority = priority
  end
end

tasks = [
  Task.new('Wash dishes', 2),
  Task.new('Do homework', 1),
  Task.new('Read book', 3)
]

priority_threshold = 2

# Use select and map to create filtered_task_names

Hint

Chain select and map to filter and then get names.

4

Print the filtered task names

Write a puts statement to print the filtered_task_names array.

Ruby

class Task
  attr_reader :name, :priority
  def initialize(name, priority)
    @name = name
    @priority = priority
  end
end

tasks = [
  Task.new('Wash dishes', 2),
  Task.new('Do homework', 1),
  Task.new('Read book', 3)
]

priority_threshold = 2

filtered_task_names = tasks.select { |task| task.priority <= priority_threshold }.map { |task| task.name }

# Print filtered_task_names

Hint

Use puts to print the array of names.

Practice

1. Which of the following best explains why functional patterns complement Object-Oriented Programming (OOP) in Ruby?

easy

A. Functional patterns make Ruby code run faster by avoiding objects.

B. Functional patterns replace the need for classes and objects entirely.

C. OOP discourages the use of methods and focuses only on data.

D. Functional patterns create small, reusable methods without side effects, improving code clarity.

Solution

1. Step 1: Understand functional patterns in Ruby

   Functional patterns emphasize small, reusable methods that avoid changing data outside their scope (no side effects).

2. Step 2: Understand OOP's role

   OOP organizes code around objects that combine data and behavior, making programs easier to manage.

3. Final Answer:

   Functional patterns create small, reusable methods without side effects, improving code clarity. -> Option D

4. Quick Check:

   Functional patterns improve clarity by avoiding side effects [OK]

Hint: Functional = small, pure methods; OOP = objects with data [OK]

Common Mistakes:

• Thinking functional replaces OOP completely
• Believing OOP ignores methods
• Assuming functional always makes code faster

2. Which Ruby syntax correctly defines a pure function that doubles a number without changing any external state?

easy

A. def double(x); x * 2; end

B. def double(x); @value = x * 2; end

C. def double(x); puts x * 2; end

D. def double(x); x *= 2; nil; end

Solution

1. Step 1: Identify pure function characteristics

   A pure function returns a value based only on input and does not change external variables or produce side effects.

2. Step 2: Check each option

   def double(x); x * 2; end returns x * 2 without changing anything else. def double(x); @value = x * 2; end changes an instance variable (@value), so it has side effects. def double(x); puts x * 2; end prints output (side effect). def double(x); x *= 2; nil; end modifies x locally but returns nil, so it doesn't return the doubled value.

3. Final Answer:

   def double(x); x * 2; end -> Option A

4. Quick Check:

   Pure function returns value only [OK]

Hint: Pure functions return values without side effects [OK]

Common Mistakes:

• Using instance variables inside pure functions
• Printing inside functions instead of returning
• Not returning the computed value explicitly

3. What is the output of this Ruby code combining OOP and functional style?

class Calculator
  def initialize(value)
    @value = value
  end

  def double
    @value * 2
  end

  def apply(func)
    func.call(@value)
  end
end

calc = Calculator.new(5)
puts calc.double
puts calc.apply(->(x) { x + 3 })

medium

A. 10
8

B. 10
15

C. 5
8

D. Error: undefined method

Solution

1. Step 1: Understand the Calculator class methods

   The double method returns @value * 2, so for 5 it returns 10. The apply method calls the passed function with @value.

2. Step 2: Evaluate the output of puts statements

   calc.double prints 10. calc.apply calls the lambda adding 3 to 5, so prints 8.

3. Final Answer:

   10 8 -> Option A

4. Quick Check:

   double = 10, apply adds 3 = 8 [OK]

Hint: Remember lambdas called with .call and return values [OK]

Common Mistakes:

• Confusing lambda call syntax
• Expecting apply to modify @value
• Mixing up output values

4. Identify the error in this Ruby code that tries to combine functional and OOP styles:

class Counter
  def initialize
    @count = 0
  end

  def increment
    @count += 1
  end

  def apply(func)
    func(@count)
  end
end

counter = Counter.new
counter.increment
puts counter.apply(->(x) { x * 2 })

medium

A. Lambda syntax is incorrect

B. increment method should return @count

C. func should be called with .call, not func()

D. Instance variable @count is not initialized

Solution

1. Step 1: Check how func is used in apply method

   In Ruby, to call a lambda or Proc, you must use .call, not func().

2. Step 2: Identify the error

   func(@count) will cause a NoMethodError because func is a Proc object and needs .call.

3. Final Answer:

   func should be called with .call, not func() -> Option C

4. Quick Check:

   Call lambdas with .call [OK]

Hint: Use .call to invoke lambdas or Procs [OK]

Common Mistakes:

• Calling lambda like a normal method
• Forgetting to initialize instance variables
• Incorrect lambda syntax

5. You want to create a Ruby class that stores a list of numbers and provides a method to return a new list with each number doubled, without changing the original list. Which approach best combines functional patterns with OOP?

hard

A. Modify the original list inside the method by doubling each element in place.

B. Define a method that returns a new array using map without modifying the original list.

C. Store the doubled values in an instance variable and return it directly.

D. Use a global variable to hold the doubled list and update it inside the method.

Solution

1. Step 1: Understand the requirement

   The method should not change the original list but return a new list with doubled values.

2. Step 2: Evaluate options for functional and OOP style

   Using map returns a new array without side effects, fitting functional style. Modifying original data or using global variables breaks this principle.

3. Final Answer:

   Define a method that returns a new array using map without modifying the original list. -> Option B

4. Quick Check:

   Use map for new array, avoid side effects [OK]

Hint: Use map to transform arrays without changing originals [OK]

Common Mistakes:

• Modifying original array instead of returning new
• Using global variables for data storage
• Storing results in instance variables unnecessarily