Why functional patterns complement OOP in Ruby - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of combining functional and OOP styles

What is the output of this Ruby code that mixes functional style with OOP?

Ruby

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

  def double_and_sum
    @numbers.map { |n| n * 2 }.reduce(0, :+)
  end
end

calc = Calculator.new([1, 2, 3])
puts calc.double_and_sum

A 6

B 9

C Error: undefined method `map' for Integer

D 12

💡 Hint

Think about how map and reduce work on arrays inside the class.

The array [1, 2, 3] is doubled element-wise to [2, 4, 6], then summed to 12.

🧠 Conceptual

intermediate

Why use functional patterns in OOP?

Which reason best explains why functional programming patterns complement object-oriented programming?

A They help manage side effects and make code easier to test.

B They replace the need for classes and objects entirely.

C They force all data to be mutable for flexibility.

D They make code run faster by avoiding objects.

💡 Hint

Think about how pure functions behave compared to methods with side effects.

Functional patterns encourage pure functions which reduce side effects, making code easier to test and maintain within OOP.

🔧 Debug

advanced

Identify the error mixing functional and OOP styles

What error does this Ruby code produce when mixing functional and OOP styles?

Ruby

class DataProcessor
  def initialize(data)
    @data = data
  end

  def process
    @data.map! { |x| x * 2 }
    @data.reduce(:+)
  end
end

processor = DataProcessor.new(10)
puts processor.process

A NoMethodError: undefined method `map!' for Integer

B TypeError: no implicit conversion of Integer into Array

C SyntaxError: unexpected end-of-input

D NilClass error when calling reduce

💡 Hint

Check the type of @data when calling map! inside the class.

The code tries to call map! on an Integer, which is invalid because map! is an Array method.

📝 Syntax

advanced

Correct functional method syntax in OOP context

Which option correctly defines a method in Ruby that uses a functional style inside a class?

Ruby

class Transformer
  def initialize(values)
    @values = values
  end

  def transform
    # Fill in the blank
  end
end

A

def transform
  @values.reduce { |sum, v| sum + v + 1 }
end

B

def transform
  @values.map { |v| v + 1 }
end

C

def transform
  @values.map! { |v| v + 1 }
end

D

def transform
  @values.each { |v| v + 1 }
end

💡 Hint

Functional style prefers returning new collections without modifying originals.

Option B returns a new array with each value incremented, following functional style without side effects.

🚀 Application

expert

Predict the final output combining OOP and functional methods

Given this Ruby code combining OOP and functional patterns, what is the final output?

Ruby

class Stats
  def initialize(numbers)
    @numbers = numbers
  end

  def mean
    @numbers.reduce(0.0, :+) / @numbers.size
  end

  def squared_diffs
    @numbers.map { |n| (n - mean) ** 2 }
  end

  def variance
    squared_diffs.reduce(0.0, :+) / @numbers.size
  end
end

stats = Stats.new([2, 4, 4, 4, 5, 5, 7, 9])
puts stats.variance.round(2)

A 3.5

B 2.0

C 4.0

D 5.0

💡 Hint

Calculate mean first, then squared differences, then average those.

The variance calculation follows the formula: average of squared differences from the mean, resulting in 4.0.