No:

indexes = [1, 2, 3]
indexes << 4
indexes # [1, 2, 3, 4]

Yes:

indexes = [1, 2, 3]
all_indexes = indexes + [4] # => [1, 2, 3, 4]

No:

hash = {:a => 1, :b => 2}
hash[:c] = 3
hash

Yes:

hash = {:a => 1, :b => 2}
new_hash = hash.merge(:c => 3)

No:

string = "hello"
string.gsub!(/l/, 'z')
string # => "hezzo"

Yes:

string = "hello"
new_string = string.gsub(/l/, 'z') # => "hezzo"

No:

output = []
output << 1
output << 2 if i_have_to_add_two
output << 3

Yes:

output = [1, (2 if i_have_to_add_two), 3].compact

No:

dogs = []
["milu", "rantanplan"].each do |name|
  dogs << name.upcase
end
dogs # => ["MILU", "RANTANPLAN"]

Yes:

dogs = ["milu", "rantanplan"].map do |name|
  name.upcase
end # => ["MILU", "RANTANPLAN"]

No:

dogs = []
["milu", "rantanplan"].each do |name|
  if name.size == 4
    dogs << name
  end
end
dogs # => ["milu"]

Yes:

dogs = ["milu", "rantanplan"].select do |name|
  name.size == 4
end # => ["milu"]

No:

length = 0
["milu", "rantanplan"].each do |dog_name|
  length += dog_name.length
end
length # => 15

Yes:

length = ["milu", "rantanplan"].inject(0) do |accumulator, dog_name|
  accumulator + dog_name.length
end # => 15

このコードの場合には累積子と要素との間に単純な演算子があるから、 ブロックを書かなくても、その演算子のシンボルを渡すだけで済む。

length = ["milu", "rantanplan"].map(&:length).inject(0, :+) # => 15

畳み込みの最終結果だけでなく(以前に見た inject)、部分的な値も欲しいケースを想像してみよう。 命令型コードでは、以下のように書く。

lengths = []
total_length = 0
["milu", "rantanplan"].each do |dog_name|
  lengths << total_length
  total_length += dog_name.length
end
lengths # => [0, 4, 15]

関数型の世界だと、 Haskell は scan と呼び、 C++ は partial_sum と呼び、 Clojure は reductions と呼ぶ。 残念なことに、Rubyにはそのような関数が存在しないので、自分で書いてみよう。 以下のようになる。

lengths = ["milu", "rantanplan"].partial_inject(0) do |dog_name|
  dog_name.length
end # => [0, 4, 15]

Enumerable#partial_inject は、以下のように書ける。

module Enumerable
  def partial_inject(initial_value, &block)
    self.inject([initial_value, [initial_value]]) do |(accumulated, output), element|
      new_value = yield(accumulated, element)
      [new_value, output << new_value]
    end[1]
  end
end

実装の詳細は重要ではなく、それよりも、抽象化の興味深いパターンを認識する時には 分離したライブラリ内にコードを書き、文書化し、テストを実施していたことが大切である。 さて、現実のニーズに沿って、(コードの)拡張を洗練させていくことにしよう。

以下のようなコードはよく見かける。

name = obj1.name
name = obj2.name if !name
name = ask_name if !name

このようなコードを目にすれば、瞬間的に容易ではないと感じるに違いない (変数はこの値を持ち次には別の値を持ち、その変数名はいたるところで繰り返されている)。 関数型アプローチは、より短くより明解だ。

name = obj1.name || obj2.name || ask_name

以下に示すより複合的な条件を伴うもう一つの例は、

def get_best_object(obj1, obj2, obj3)
  return obj1 if obj1.price < 20
  return obj2 if obj2.quality > 3
  obj3
end

以下のような現実の式として書くことができる。

def get_best_object(obj1, obj2, obj3)
  if obj1.price < 20
    obj1
  elsif obj2.quality > 3
    obj2
  else
    obj3
  end
end

実際、わずかに騒がしいけれど、 その論理は後置 if/unless の一味よりもはるかに明解だ。 経験則として、副作用(side-effect)の実行が目的である場合に限れば 後置条件節を使用すべきであるが、変数への代入や(関数の)リターンには当てはまらない。

country = Country.find(1)
country.invade if country.has_oil?
# more code here

ありきたりの Ruby は列挙オブジェクト(Enumerable)から ハッシュ(Hash)への直接的な変換手段を持たない (個人的見解では、悲しい欠陥だ)。 なぜだろうか、初心者は、以下に示すような実にひどいパターンで書き続けている (そして、どうしてそれを非難できよう)。

hash = {}
input.each do |item|
  hash[item] = process(item)
end
hash

これはひどい、ひどすぎる。でも、これの手短な改良には何があるだろうか？ 過去にはHashコンストラクタは、 key/value ペアが連続する平坦な配列を必要としていた (げげっ、平坦な配列の写像(map)を記述するのか？ Lispなら普通だけど、それでもまだ格好悪いよ)。 幸いにも、最新版の Ruby では、 (hash.to_a の逆演算として)ずっと直感的に key/value のペアを(直に)受け取ることもできるから、 以下のように書ける。

Hash[input.map do |item|
  [item, process(item)]
end]

悪くはないが、自然なコーディングという方向性からはやや外れている。 Ruby ではオブジェクトへのメソッド呼び出しを右から左へと書くことを期待する。 そして「好ましい」関数型の道とは、 inject を使うことである。

input.inject({}) do |hash, item|
  hash.merge(item => process(item))
end

これがまだ騒がしすぎることは誰もが認めるが、 それゆえモジュール Hash 内のメソッドとして (その騒がしいコードを)移動するのが望ましく、 以下に示すように、まさしくそれを Facets で実践している。

module Enumerable
  def mash(&block)
    self.inject({}) do |output, item|
      key, value = block_given? ? yield(item) : item
      output.merge(key => value)
    end
  end
end

["functional", "programming", "rules"].map { |s| [s, s.length] }.mash
# {"rules"=>5, "programming"=>11, "functional"=>10}

あるいは、ブロックを伴う mash を使っても一行で書ける。

["functional", "programming", "rules"].mash { |s| [s, s.length] }
# {"rules"=>5, "programming"=>11, "functional"=>10}