Question

I’ve got a Ruby method like the following:

# Retrieve all fruits from basket that are of the specified kind.
def fruits_of_kind(kind)
  basket.select { |f| f.fruit_type == kind.to_s }
end

Right now, you can call this like:

fruits_of_kind(:apple)    # => all apples in basket
fruits_of_kind('banana')  # => all bananas in basket

and so on.

How do I change the method so that it will correctly handle iterable inputs as well as no inputs and nil inputs? For example, I’d like to be able to support:

fruits_of_kind(nil) # => nil
fruits_of_kind(:apple, :banana)    # => all apples and bananas in basket
fruits_of_kind([:apple, 'banana']) # => likewise

Is this possible to do idiomatically? If so, what’s the best way to write methods so that they can accept zero, one, or many inputs?

Answer 1

def fruits_of_kind(kind)
    return nil if kind.nil?

    result = []

    ([] << kind).flatten.each{|k| result << basket.select{|f| f.fruit_type == k.to_s }}

    result
end

The ‘splat’ operator is probably the best way to go, but there are two things to watch out for: passing in nil or lists. To modify Pesto’s solution for the input/output you’d like, you should do something like this:

def fruits_of_kind(*kinds)
  return nil if kinds.compact.empty? 

  basket.select do |fruit|
    kinds.flatten.each do |kind|
      break true if fruit.fruit_type == kind.to_s
    end == true #if no match is found, each returns the whole array, so == true returns false
  end
end

If you pass in nil, the * converts it to [nil]. If you want to return nil instead of an empty list, you have to compact it (remove nulls) to [], then return nil if it’s empty.

If you pass in a list, like [:apple, ‘banana’], the * converts it to [[:apple, ‘banana’]]. It’s a subtle difference, but it’s a one-element list containing another list, so you need to flatten kinds before doing the “each” loop. Flattening will convert it to [:apple, ‘banana’], like you expect, and give you the results you’re looking for.

EDIT: Even better, thanks to Greg Campbell:

   def fruits_of_kind(basket, kind)
       return nil if kind.nil?

       kind_list = ([] << kind).flatten.map{|kind| kind.to_s}

       basket.select{|fruit| kind_list.include?(fruit) } 
   end

OR (using splat)

   def fruits_of_kind(*kinds)
       return nil if kinds.compact.empty?

       kind_list = kinds.flatten.map{|kind| kind.to_s}

       basket.select{|fruit| kind_list.include?(fruit.fruit_type) } 
   end