This weeks Ruby Tuesday entry covers Enumerable#any?.

Enumerable#any? takes a block and returns true if the block returns a truthy value for any of the elements in the enumeration, otherwise it returns false.

[1, 2, 3, 4, 5, 6].any? {|x| x.even?}
# => true
["foo", "bar", "snafu", "Snuffleupagus"].any? {|x| x.size > 10}
# => true
["foo", "bar", "snafu", "Snuffleupagus"].any? {|x| x.size < 2}
#=> false

The block is optional for Enumerable#any?, and if not specified, any uses the block {|obj| obj} by default.

[nil, nil, nil].any?
# => false
[false, nil].any?
# => false
[1, 2, 3].any?
# => true

Enumerable#any? is eager, so if it finds an element where the block evaluates to a truthy value it stops processing the rest of the enumerable.

Benchmark.realtime{  (1..20000000).lazy.select(&:even?).any?{|x| x.even? } }
# => 3.6e-05
Benchmark.realtime{  (1..20000000).lazy.select(&:even?).any?{|x| x.odd? } }
# => 5.709414

Ruby also has counterparts for any? which are Enumerable#all? and Enumerable#none?. These behave the similiar as Enumerable#any?, except that Enumerable#all? checks to that the return value of the block is truthy for all elements.

[1, 3, 5, 8].all?{|x| x.odd?}
# => false
[1, 3, 5, 81].all?{|x| x.odd?}
# => true
["foo", "bar", "snafu", "Snuffleupagus"].all?{|x| x.size > 10}
# => false
["foo", "bar", "snafu", "Snuffleupagus"].all?{|x| x.size > 2}
# => true
[true, true, true].all?
# => true
["false", true, true].all?
# => true
[true, true, nil].all?
# => false
[false, nil].all?
# => false

While Enumerable#none checks the that return value of the block is a falsey value for all elements.

[1, 3, 5, 7, 9].none?{|x| x.even?}
# => true
[1, 3, 5, 7, 8].none?{|x| x.even?}
# => false
[true, true, true].none?
# => false
[nil, nil, false, nil].none?
# => true

Both Enumerable#all? and Enumerable#none? are both eager as well.

Benchmark.realtime{  (1..20000000).lazy.select(&:even?).all?{|x| x.even? } }
# => 5.250464
Benchmark.realtime{  (1..20000000).lazy.select(&:odd?).all?{|x| x.even? } }
# => 3.3e-05
Benchmark.realtime{  (1..20000000).lazy.select(&:odd?).none?{|x| x.even? } }
# => 5.365924
Benchmark.realtime{  (1..20000000).lazy.select(&:even?).none?{|x| x.even? } }
# => 3.7e-05

–Proctor

Today’s Ruby Tuesday method is Enumerable#partition.

Enumerable#partition takes a block and returns an array of two arrays. The first item in the returned array is an array of items for which the block returns a truthy value. The second item in the returned array are the items for which the block returns a falsey value.

[:a, 1, "b", :c, [1, 2, 3,]].partition{|x| x.is_a? Symbol}
# => [[:a, :c], [1, "b", [1, 2, 3]]]
[1, 2, 3, 4, 5, 6, 7].partition{|x| x.even?}
# => [[2, 4, 6], [1, 3, 5, 7]]
["foo", "snafu", "bar", "hello world"].partition{|x| x.size < 5}
# => [["foo", "bar"], ["snafu", "hello world"]]
["foo", "snafu", "bar", "hello world"].partition{|x| x.size < 15}
# => [["foo", "snafu", "bar", "hello world"], []]
[1, 2, 3, 4].partition{|x| x}
# => [[1, 2, 3, 4], []]
[1, 2, 3, 4].partition{|x| nil}
# => [[], [1, 2, 3, 4]]

–Proctor

Today’s Ruby Tuesday covers Enumerable#zip.

Enumerable#zip weaves together elements of multiple Enumerables. It iterates through each item in the enum and combines it with the corresponding element from each of the arguments passed to zip, resulting in an array of arrays.

[:a, :b, :c].zip([1, 2, 3])
# => [[:a, 1], [:b, 2], [:c, 3]]
[:a, :b, :c].zip([1, 2, 3], [:foo, :bar, :baz])
# => [[:a, 1, :foo], [:b, 2, :bar], [:c, 3, :baz]]

If an item in the argument list is shorter then the enum that zip is being called on, nil is used where the item would have been added.

[:a, :b, :c].zip([1], [:foo, :bar, :baz, :snafu])
# => [[:a, 1, :foo], [:b, nil, :bar], [:c, nil, :baz]]

The length of the returned array is the length of the enum that zip is being called on. Any extra elements in the enumerable passed to zip are ignored, and if are in a lazy enumerble not computed.

[:a, :b, :c].zip([1, 2, 3, 4], [:foo, :bar, :baz, :snafu])
# => [[:a, 1, :foo], [:b, 2, :bar], [:c, 3, :baz]]

### Only takes what is needed ###
require 'benchmark'
# => true
Benchmark.measure do
  [:a, :b].zip( (1..1_000_000_000_000).lazy.map{|x| x*x*x} ) 
end
# => #<Benchmark::Tms:0x007fd5749d9288
#  @cstime=0.0,
#  @cutime=0.0,
#  @label="",
#  @real=4.3e-05,
#  @stime=0.0,
#  @total=0.0,
#  @utime=0.0>

#### For much much less, took 8+ seconds ####
Benchmark.measure do
  [:a, :b].zip( (1..10_000_000).map{|x| x*x*x} )   
end
# => #<Benchmark::Tms:0x007faed4779e00
#  @cstime=0.0,
#  @cutime=0.0,
#  @label="",
#  @real=8.616259,
#  @stime=0.7200000000000002,
#  @total=8.53,
#  @utime=7.809999999999999>

Enumerable#zip can also be given a block. If a block is provided, the combined array of items is passed to the block, and not returned as a result. This behavior is distinct from Enumerable#each in that each still returns the Enumerable it was invoked on, where as zip returns nil as it’s result when a block is given.

[:a, :b, :c].zip([1, 2, 3, 4], [:foo, :bar, :baz, :snafu]) { |items| puts items.to_s }
# [:a, 1, :foo]
# [:b, 2, :bar]
# [:c, 3, :baz]
# => nil
[:a, :b, :c].zip([1, 2, 3, 4], [:foo, :bar, :baz, :snafu]).each { |items| puts items.to_s }
# [:a, 1, :foo]
# [:b, 2, :bar]
# [:c, 3, :baz]
# => [[:a, 1, :foo], [:b, 2, :bar], [:c, 3, :baz]]

–Proctor

Today’s Ruby Tuesday is Enumerable#reduce, also known as Enumerable#inject.

Enumerable#reduce works against an enum and takes a initial value for the accumulator and two parameter block. The first parameter to the block is the current accumulated value, and second parameter is the current element in the iteration. If no accumulator value is specified, the first item in the enum is taken to be used as the accumulator value.

["baz","Supercalifragilisticexpialidocious", "qwerty"].reduce("") do |shortest, item|
  item.length < shortest.length ? item : shortest
end
# => ""
["baz","Supercalifragilisticexpialidocious", "qwerty"].reduce do |longest, item|
  item.length > longest.length ? item : longest
end
# => "Supercalifragilisticexpialidocious"
["baz", "Supercalifragilisticexpialidocious", "qwerty"].reduce do |shortest, item|
  item.length < shortest.length ? item : shortest
end
# => "baz"

Calling reduce on an empty enum just returns the accumulator, or if no initial value for the accumulator given returns the result of calling first on the enum, which in the case of Array is nil.

[].reduce(:accum){|accum, item| accum * item}
# => :accum
[].reduce{|accum, item| accum * item}
# => nil

Enumerable#reduce can also take a symbol instead of a block, which is the name of the method to invoke on the accumulator value. This form of reduce also takes an initial accumulator value, or uses the first item as the accumulator.

[1, 2, 3, 4, 5].reduce(:+)
# => 15
[1, 2, 3, 4, 5].reduce(:*)
# => 120
[1, 2, 3, 4, 5].reduce(10, :*)
# => 1200
[100, 10, 2].reduce(:/)
# => 5
[100, 10, 2].reduce(1_000_000, :/)
# => 500

–Proctor

Today’s Ruby Tuesday method is Enumerable#map, also known as Enumerable#collect.

Enumerable#map is a function with a long lineage. Enumerable#map takes a set of items, and maps the inputs onto a new set of values via a transformation function, or in the case of Ruby, a block.

[1, 2, 3, 4].map{ |x| x + 1 }
# => [2, 3, 4, 5]
[1, 2, 3, 4].map{ |x| x * x }
# => [1, 4, 9, 16]

In Ruby, the map method is an alias of Enumerable#collect.

[1, 2, 3, 4].map{ |x| x * x }
# => [1, 4, 9, 16]
[1, 2, 3, 4].collect{ |x| x * x }
# => [1, 4, 9, 16]

Ruby also has some ways of taking existing methods, and passing them as the block to be invoked by the map function. If we want to do a transform by calling a method on the object passed to the block, we can prepend the name of the method with a &: and pass that to the map function as an argument.

['i', 'b', 'm'].map{ |x| x.upcase }
=> ["I", "B", "M"]
['i', 'b', 'm'].map(&:upcase)
=> ["I", "B", "M"]

You want to be careful with this though, as not all functions on an object are transformation functions but may modify the underlying object, which may cause confusion to readers of your code if they are expecting the original enumeration to be unchanged.

items = ['i', 'b', 'm']
# => ["i", "b", "m"]
items.map(&:upcase)
# => ["I", "B", "M"]
items
# => ["i", "b", "m"]
items = ['i', 'b', 'm']
# => ["i", "b", "m"]
items.map(&:upcase!)
#=> ["I", "B", "M"]
items
# => ["I", "B", "M"]