What is the Ruby equivalent of Haskell's scanl?

Question

This question presents a version of Haskell's scanl in Python, but is there a Ruby version of this function?

Answer 1

You can use reduce() and implement it by yourself.

def scanl(op, init, range)
  op = op.to_proc unless op.is_a?(Proc)
  range.reduce([init]) { |a, e| a.push(op.call(a.last,e)) }
end

p scanl(lambda { |a, b| a + b }, 0, 1..10)
#=> [0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55]
p scanl(:+, 0, 1..10)
#=> [0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55]

Alternatively you can use map() and put the initial element in front of the array.

def scanl(op, init, range)                             
  op = op.to_proc unless op.is_a?(Proc)                
  acc = init                                           
  range.map { |e| acc = op.call(acc, e) }.unshift(init)
end                                                 

Answer 2

In Ruby 2.0, where the Enumerator class exists, we can build a nicer implementation that works properly with infinite ranges:

def scanl(elem, &op)
  Enumerator.new do |yielder|
    acc = elem
    loop do
      yielder << acc
      acc = op.call(acc)
    end
  end.lazy
end

And use it like so:

scanl(1, &:next).take(10)                                                                                                                                                                                                                                     
#=> #<Enumerator::Lazy: ...>
scanl(1, &:next).take(10).force                                                                                                                                                                                                                                     
#=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
fib = scanl([0,1]) {|x, y| [y, x + y]}.map(&:first)
fib.take(10).force
#=> [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Answer 3

Probably a nicer version could be written, but this is what I came up with:

require 'spec_helper'

class Array
  def scanl accumulator, &block
    results = [accumulator] + self
    results.each_with_index do |e, i|
      results[i] = block.call(accumulator, e)
      accumulator = results[i]
    end
    results
  end
end

describe "#scanl" do
  it 'is similar to foldl, but returns a list of successive reduced values from the left' do
    # example from http://learnyouahaskell.com/higher-order-functions
    expect([3, 5, 2, 1].scanl(0, &:+)).to eq([0,3,8,10,11])
  end
end

I considered changing scanl to take just a method name like :+ instead of a block to be more like reduce. Thoughts?