Overview

The loop method creates an infinite iteration in Ruby. Ruby implements loop as a method that repeatedly executes a given block until explicitly terminated. The method belongs to the Kernel module, making it available throughout Ruby programs without requiring specific class instantiation.

Ruby's loop method differs from traditional while loops by providing built-in exception handling for flow control. The method catches StopIteration exceptions automatically, allowing break statements to exit cleanly. This design integrates with Ruby's iterator protocol and provides consistent behavior across different loop constructs.

loop do
  puts "This runs forever"
  break if some_condition
end

The method accepts a block and returns nil when terminated normally through break. Without termination conditions, loop executes indefinitely, requiring external intervention to stop execution.

counter = 0
loop do
  counter += 1
  puts counter
  break if counter >= 3
end
# => nil

Ruby treats loop as the foundational infinite iterator. The method serves as the basis for other iterative constructs and provides the most direct approach to infinite iteration patterns.

Basic Usage

The loop method requires a block to execute repeatedly. Ruby evaluates the block content on each iteration, providing access to local variables and method calls within the loop scope.

# Basic counting loop
i = 0
loop do
  puts "Count: #{i}"
  i += 1
  break if i > 5
end

Breaking from loops requires explicit break statements. The break keyword terminates loop execution and returns control to the code following the loop block. Ruby allows break to carry return values.

result = loop do
  user_input = gets.chomp
  break user_input if user_input != "continue"
  puts "Continuing..."
end
puts "You entered: #{result}"

The next keyword skips to the next iteration without terminating the loop. Ruby evaluates the block from the beginning when next executes.

loop do
  number = rand(1..10)
  next if number.even?
  puts "Odd number: #{number}"
  break if number > 7
end

Nested loops require careful break management. Inner breaks only terminate their immediate loop context, leaving outer loops active.

loop do
  puts "Outer loop"
  inner_count = 0
  
  loop do
    inner_count += 1
    puts "  Inner: #{inner_count}"
    break if inner_count >= 3
  end
  
  break if inner_count >= 3
end

Advanced Usage

Complex loop patterns combine loop with Ruby's iterator methods and control structures. The method supports sophisticated iteration scenarios through block variable manipulation and conditional logic.

# Queue processing with dynamic conditions
queue = %w[task1 task2 task3]
processed = []

loop do
  current_task = queue.shift
  break unless current_task
  
  # Simulate processing time
  sleep(0.1)
  processed << current_task.upcase
  
  # Add new tasks based on conditions
  queue << "subtask_of_#{current_task}" if current_task.include?("task2")
end

puts processed

The loop method integrates with Ruby's exception handling mechanisms. Custom exception types can control loop behavior beyond basic break statements.

class RetryableError < StandardError; end
class FatalError < StandardError; end

attempts = 0
loop do
  attempts += 1
  
  begin
    # Simulate unreliable operation
    raise RetryableError if rand < 0.3 && attempts < 5
    raise FatalError if rand < 0.1
    
    puts "Operation succeeded on attempt #{attempts}"
    break
    
  rescue RetryableError
    puts "Retry #{attempts}/5"
    next
  rescue FatalError
    puts "Fatal error occurred"
    break
  end
end

State machines benefit from loop-based implementations. Ruby's loop method provides clean state transition logic through case statements and conditional breaks.

class StateMachine
  def initialize
    @state = :idle
    @counter = 0
  end
  
  def run
    loop do
      case @state
      when :idle
        puts "Idle state"
        @state = :working if @counter > 2
        
      when :working
        puts "Working state"
        @counter += 1
        @state = :finished if @counter > 5
        
      when :finished
        puts "Finished state"
        break
      end
      
      @counter += 1
      sleep(0.5)
    end
  end
end

StateMachine.new.run

Generator patterns use loop with Enumerator objects to create lazy evaluation sequences. This approach separates iteration logic from data consumption.

fibonacci_generator = Enumerator.new do |yielder|
  a, b = 0, 1
  loop do
    yielder << a
    a, b = b, a + b
  end
end

# Take first 10 Fibonacci numbers
puts fibonacci_generator.take(10)

Common Pitfalls

Infinite loops without termination conditions consume CPU resources indefinitely. Ruby provides no automatic timeout mechanisms for loop method execution, requiring explicit break logic in all loop constructs.

# DANGEROUS: No termination condition
loop do
  puts "This will run forever"
  # Missing break statement causes infinite execution
end

# SAFE: Always include termination logic
counter = 0
loop do
  puts "This will terminate"
  counter += 1
  break if counter >= 100
end

Variable scope issues arise when loop blocks capture external variables incorrectly. Ruby's block scoping rules can lead to unexpected variable mutations and memory retention.

# Problem: Unintended variable capture
items = []
loop do
  item = expensive_calculation()
  items << item
  break if items.size >= 1000
  # item remains in memory due to block scope
end

# Solution: Explicit variable management
items = []
loop do
  break if items.size >= 1000
  items << expensive_calculation()
  # Local variables released each iteration
end

Exception handling complications occur when breaks interact with begin/rescue blocks. Ruby's exception propagation through loop blocks requires careful consideration of rescue scope.

# Problematic exception handling
loop do
  begin
    risky_operation()
    break  # This break can be masked by exceptions
  rescue StandardError
    puts "Error occurred"
    # Break is unreachable if exception always occurs
  end
end

# Better approach
loop do
  success = false
  begin
    risky_operation()
    success = true
  rescue StandardError => e
    puts "Error: #{e.message}"
  end
  
  break if success || should_abort?
end

Memory accumulation problems develop when loop iterations create objects without proper cleanup. Ruby's garbage collector cannot free objects still referenced within loop scope.

# Memory leak pattern
data_store = []
loop do
  large_object = create_large_data_structure()
  data_store << large_object  # Objects accumulate
  break if data_store.size >= 1000
end

# Memory-conscious pattern
loop do
  large_object = create_large_data_structure()
  process_data(large_object)
  # large_object eligible for GC each iteration
  break if processed_enough?
end

Performance & Memory

Loop performance in Ruby depends primarily on block complexity rather than the loop mechanism itself. The loop method adds minimal overhead compared to block execution time, making optimization focus necessary on block contents.

require 'benchmark'

# Performance comparison
Benchmark.bm do |x|
  x.report("loop") do
    i = 0
    loop do
      i += 1
      break if i >= 1_000_000
    end
  end
  
  x.report("while") do
    i = 0
    while i < 1_000_000
      i += 1
    end
  end
end
# Results show minimal difference between constructs

Memory usage patterns differ based on variable scope within loop blocks. Ruby retains references to block-scoped variables throughout loop execution, potentially preventing garbage collection.

# High memory usage pattern
results = []
loop do
  data = generate_large_dataset()  # Retained in block scope
  processed = expensive_processing(data)
  results << processed.summary
  break if results.size >= 100
end

# Optimized memory pattern
results = []
loop do
  break if results.size >= 100
  
  summary = nil
  # Limit variable scope
  begin
    data = generate_large_dataset()
    processed = expensive_processing(data)
    summary = processed.summary
  end
  
  results << summary
  # data and processed eligible for GC
end

CPU profiling reveals that loop overhead remains constant while block execution dominates performance characteristics. Ruby's loop implementation optimizes for minimal method call overhead.

# CPU-intensive loop optimization
def optimized_processing_loop(data_source)
  cached_methods = {
    processor: method(:heavy_calculation),
    validator: method(:validate_result)
  }
  
  loop do
    item = data_source.next_item
    break unless item
    
    # Use cached method references
    result = cached_methods[:processor].call(item)
    next unless cached_methods[:validator].call(result)
    
    yield result
  end
end

Reference

Loop Method Signature

Control Flow Keywords

Exception Handling

Common Patterns

# Basic infinite loop
loop do
  # code
  break if condition
end

# Loop with return value
result = loop do
  # code
  break value if condition
end

# Loop as enumerator
enum = loop
enum.next  # Raises StopIteration

# Nested loop breaking
outer_loop = loop do
  inner_result = loop do
    break "inner" if inner_condition
  end
  break "outer: #{inner_result}" if outer_condition
end

Memory Management Guidelines

• Minimize block-scoped variable lifetime
• Use explicit scoping with begin/end blocks
• Process large datasets in chunks
• Monitor memory growth in long-running loops
• Consider Enumerator for large data sequences

Performance Considerations

• Block complexity dominates performance impact
• Method call overhead negligible
• Variable allocation patterns affect memory usage
• Exception handling adds minimal overhead
• Break conditions evaluated each iteration\