Pure functions concept in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a pure function call

What is the output of this Ruby code that uses a pure function?

Ruby

def multiply_by_two(x)
  x * 2
end

result = multiply_by_two(5)
puts result

A 10

B 5

C nil

D Error

💡 Hint

Think about what the function does with the input number.

The function multiply_by_two returns the input number multiplied by 2 without changing anything else. So 5 * 2 equals 10.

🧠 Conceptual

intermediate

Identifying pure functions

Which of the following Ruby methods is a pure function?

A

def add_random(x)
  x + rand(10)
end

B

def square(x)
  x * x
end

C

def increment_counter(x)
  $counter += 1
  x + $counter
end

D

def print_value(x)
  puts x
  x
end

💡 Hint

A pure function always returns the same output for the same input and has no side effects.

Only the square method returns the same output for the same input and does not change anything outside itself.

🔧 Debug

advanced

Why is this function not pure?

This Ruby function looks simple but is not pure. What causes it to be impure?

Ruby

def add_to_list(item, list = [])
  list << item
  list
end

result1 = add_to_list(1)
result2 = add_to_list(2)
puts result2.inspect

A The function returns a list which is mutable, so it is impure.

B The function uses puts which is a side effect.

C The default list argument is shared between calls, causing side effects.

D The function does not return a value explicitly.

💡 Hint

Think about what happens to the default list argument when the function is called multiple times.

In Ruby, default arguments are evaluated once. The same list is used in every call, so the function changes external state making it impure.

📝 Syntax

advanced

Which function definition is a pure function?

Select the Ruby function that is syntactically correct and pure.

A

def add(x, y)
  x + y
  puts "Sum calculated"
end

B

def add(x, y)
  return x + y if x > 0
end

C

def add(x, y)
  @sum = x + y
end

D

def add(x, y)
  x + y
end

💡 Hint

A pure function must not have side effects and must return a value consistently.

Option D returns the sum without side effects. Option D prints output, C changes instance variable, D returns nil if x <= 0.

🚀 Application

expert

Predict the output of a function with external state

What will be printed when this Ruby code runs?

Ruby

def counter
  @count ||= 0
  @count += 1
end

puts counter
puts counter
puts counter

A

1
2
3

B

0
1
2

C

1
1
1

D Error: undefined method or variable

💡 Hint

Look at how the instance variable @count changes each time the function is called.

The @count variable starts at 0 and increments by 1 each call, so outputs are 1, 2, and 3.

Practice

1. Which of the following best describes a pure function in Ruby?

easy

A. A function that reads user input and prints output directly.

B. A function that always returns the same output for the same input and has no side effects.

C. A function that modifies global variables to keep track of state.

D. A function that changes the value of its arguments.

Solution

1. Step 1: Understand pure function definition

   A pure function always returns the same result when given the same input and does not affect anything outside itself.

2. Step 2: Compare options to definition

   A function that always returns the same output for the same input and has no side effects. matches this definition exactly. Options A, B, and D involve side effects or changing external state.

3. Final Answer:

   A function that always returns the same output for the same input and has no side effects. -> Option B

4. Quick Check:

   Pure function = consistent output + no side effects [OK]

Hint: Pure functions never change outside data and always return same output [OK]

Common Mistakes:

• Thinking functions that modify variables are pure
• Confusing input/output consistency with side effects
• Assuming printing output is allowed in pure functions

2. Which Ruby function below is a pure function?

easy

A. def add(a, b); a + b; end

B. def add(a, b); puts a + b; end

C. def add(a, b); @sum = a + b; end

D. def add(a, b); print a + b; end

Solution

1. Step 1: Check each function for side effects and output consistency

   def add(a, b); a + b; end returns sum without changing anything outside or printing. def add(a, b); puts a + b; end prints (side effect). def add(a, b); @sum = a + b; end changes instance variable (side effect). def add(a, b); print a + b; end prints (side effect).

2. Step 2: Identify pure function

   Only def add(a, b); a + b; end meets pure function rules: same output for same input, no side effects.

3. Final Answer:

   def add(a, b); a + b; end -> Option A

4. Quick Check:

   Pure function = no side effects + returns value [OK]

Hint: Pure functions return values without printing or changing variables [OK]

Common Mistakes:

• Confusing printing output with returning value
• Assuming modifying instance variables is allowed
• Assuming print doesn't cause side effects

3. What is the output of this Ruby code?

def multiply(x, y)
  x * y
end

result = multiply(3, 4)
puts result

medium

A. Error

B. nil

C. 12

D. 7

Solution

1. Step 1: Understand the multiply function

   The function returns the product of x and y, so multiply(3, 4) returns 12.

2. Step 2: Check the output statement

   puts prints the returned value, so it prints 12.

3. Final Answer:

   12 -> Option C

4. Quick Check:

   multiply(3,4) = 12 [OK]

Hint: Pure functions return predictable output; multiply(3,4) = 12 [OK]

Common Mistakes:

• Thinking function returns nil if no explicit return
• Confusing addition with multiplication
• Expecting error due to missing return keyword

4. Identify the error in this Ruby function that is supposed to be pure:

def increment(n)
  n += 1
  puts n
end

medium

A. It modifies the input variable n.

B. It uses invalid syntax for increment.

C. It does not return any value explicitly.

D. It prints output, causing a side effect.

Solution

1. Step 1: Check for side effects

   The function prints the value of n, which is a side effect because it affects outside world.

2. Step 2: Verify other aspects

   Modifying n locally is allowed; syntax is correct; implicit return is allowed but printing breaks purity.

3. Final Answer:

   It prints output, causing a side effect. -> Option D

4. Quick Check:

   Pure functions must not print or cause side effects [OK]

Hint: Printing inside function breaks purity due to side effects [OK]

Common Mistakes:

• Thinking local variable change breaks purity
• Assuming implicit return is an error
• Ignoring side effects caused by printing

5. You want to write a pure function in Ruby that takes a list of numbers and returns a new list with each number doubled. Which implementation is pure?

hard

A. def double_list(nums)
nums.map { |n| n * 2 }
end

B. def double_list(nums)
nums.collect! { |n| n *= 2 }
nums
end

C. def double_list(nums)
nums.map! { |n| n * 2 }
end

D. def double_list(nums)
nums.clear
nums.push(2, 4, 6)
end

Solution

1. Step 1: Understand pure function requirements

   A pure function returns new data without changing input or external state.

2. Step 2: Analyze each option

   def double_list(nums) nums.collect! { |n| n *= 2 } nums end uses collect! which modifies original array (side effect). def double_list(nums) nums.map { |n| n * 2 } end returns a new array with doubled values without changing original. def double_list(nums) nums.map! { |n| n * 2 } end uses map! which modifies original array (side effect). def double_list(nums) nums.clear nums.push(2, 4, 6) end clears and modifies original array (side effect).

3. Final Answer:

   def double_list(nums) nums.map { |n| n * 2 } end -> Option A

4. Quick Check:

   Pure function = no input change + returns new data [OK]

Hint: Use non-destructive methods like map, avoid modifying input [OK]

Common Mistakes:

• Using destructive methods like map! or clear
• Modifying input array instead of returning new one
• Confusing each with map for transformation