Question

Ruby use the functions from “functional concept” heavily, such as map, each. They really depend on a self-contained function which is so called block in Ruby.

It is very common to loop though a 2d array, make an string about the elements.

In java, it may looks like

   public String toString(){
        String output = "[";
        for (int i =0; i<array.length; i++) {
            output+= "Row "+(i+1)+" : ";
            for (int j=0; j<array[0].length;j++ ) {
                output += array[i][j]+", ";
            }
            output += "\n";
        }

        return output += "]";
    }

I tried to rewrite such a thing in “Ruby functional Style”, but I think there are still some improvements. Eg. I want to remove the mutable variable output

  def to_s
        output = "[\n"
        @data.each_with_index do |row,i|
            output << "Row #{i+1} : "
            row.each { |num| output << "#{num}," }
            output << "\n"
        end

        output+"]"
    end

Answer 1

Whenever you see the pattern:

1. initialize an accumulator (in your case output)
2. on each iteration of some collection modify the accumulator (in your case append to it)
3. return the accumulator

that’s a fold, or in Ruby terms an inject.

Actually, that’s a bit of a tautology. A fold is a universal method of iteration: everything that can be expressed by iterating over the elements of a collection can also be expressed as a fold over the collection. In other words: all methods on Enumerable (including each!) could also be defined in terms of inject as the primitive method instead of each.

Think about it this way: a collection can either be empty or there can be a current element. There’s no third option, if you cover those two cases, then you have covered everything. Well, fold takes two arguments: one which tells it what to do when the collection is empty, and one which tells it what to do with the current element. Or, put yet another way: you can see a collection as a series of instructions and fold is an interpreter for those instructions. There are only two kinds of instructions: the END instruction and a VALUE(el) instruction. And you can supply the interpreter code for both those instructions to the fold.

In Ruby, the second argument is not part of the argument list, it is the block.

So, what’s it look like as a fold?

def to_s
  @data.each_with_index.inject("[\n") do |acc, (row, i)|
    acc + "Row #{i+1} : #{row.join(',')}\n"
  end + ']'
end

If you’re curious about whether or not the each_with_index may infect your code with some non-functional impurity, rest assured that you can just as easily get rid of it by including the index in the accumulator:

def to_s
  @data.inject(["[\n", 1]) do |(s, i), row|
    [s + "Row #{i} : #{row.join(',')}\n", i+1]
  end.first + ']'
end

Also note that in the first case, with the each_with_index, we’re not actually doing anything “interesting” with the accumulator, unlike the second case, where we are using it to keep count of the index. In fact, the first case is actually a restricted form of fold, it doesn’t use all of its power. It really is just a map:

def to_s
  "[\n" + @data.map.with_index(1) do |row, i|
    "Row #{i} : #{row.join(',')}\n"
  end.join + ']'
end

In my personal opinion, it would actually be perfectly okay to use (mutable) string appending here instead of string concatenation:

def to_s
  "[\n" << @data.map.with_index(1) do |row, i|
    "Row #{i} : #{row.join(',')}\n"
  end.join << ']'
end

This saves us from creating a couple of unnecessary string objects, but more importantly: it is more idiomatic. The real problem is shared mutable state, but we’re not sharing our mutable string here: when to_s returns its caller does get access to the string, but to_s itself has returned and thus no longer has access to it.

If you want to get real fancy, you could even use string interpolation:

def to_s
  %Q<[\n#{@data.map.with_index(1) do |row, i|
    "Row #{i} : #{row.join(',')}\n"
  end.join}]>
end

Unfortunately, this not only breaks IRb’s syntax highlighting, but also my brain’s 😉