Smart Defaults in Ruby: Setting Method Arguments Dynamically

In Ruby, method arguments can have default values, including values based on other arguments, constants, or even instance variables. This is a powerful feature that allows for flexible method definitions.

Static Default Values

The most common way to set default values in Ruby is by assigning a static value to a method argument. This ensures that if the caller does not provide a value, the method will use a predefined fallback.

def order_coffee(size:, milk: "almond milk")
  puts "You ordered a #{size} coffee with #{milk}."
end

Example Usage

order_coffee(size: "small")
# Outputs: You ordered a small coffee with almond milk.

order_coffee(size: "large", milk: "oat milk")
# Outputs: You ordered a large coffee with oat milk.

Here, milk defaults to "almond milk" unless explicitly specified.

Default Values Based on Arguments

Now, let's make the default value dynamic by basing it on the size parameter. If you don’t specify a milk preference, the barista might default to a milk type based on the coffee size.

def order_coffee(size:, milk: DEFAULT_MILK[size])
  puts "You ordered a #{size} coffee with #{milk}."
end

Example Usage

Suppose we define the DEFAULT_MILK constant like this:

DEFAULT_MILK = {
  "small" => "regular milk",
  "medium" => "almond milk",
  "large" => "oat milk"
}

Calling order_coffee(size: "medium") will automatically use:

puts "You ordered a medium coffee with almond milk."

Difference Between Dynamic and Static Defaults

Key Differences:

Using milk: DEFAULT_MILK[size] dynamically assigns the default based on the size parameter. This allows for flexible defaults based on input.
Using milk: "almond milk" sets a static default. If the caller does not specify a milk type, it will always default to "almond milk," regardless of the coffee size.

Dynamic defaults (using a hash or lookup table) are useful when the default value depends on other arguments. Static defaults work well when the default should be the same for all cases.

Using Instance Variables as Default Values

If you want to use instance variables instead of constants, be aware that instance variables are not available at the time the method is defined. However, you can work around this by using self or setting the value inside the method:

class CoffeeOrder
  def initialize
    @default_milk = {
      "small" => "regular milk",
      "medium" => "almond milk",
      "large" => "oat milk"
    }
  end

  def order_coffee(size:, milk: nil)
    milk ||= @default_milk[size]
    puts "You ordered a #{size} coffee with #{milk}."
  end
end

order = CoffeeOrder.new
order.order_coffee(size: "large")
# Outputs: You ordered a large coffee with oat milk.

Key Takeaways

You can use method arguments as default values for other arguments.
Static defaults apply a fixed fallback value regardless of other parameters.
Dynamic defaults (e.g., using a constant lookup) allow for context-aware default values.
Instance variables cannot be directly used as default values, but you can assign them within the method using ||=.

You can write more concise and maintainable Ruby code by leveraging these patterns. Happy coding!