One Big Library.

Ok, so I'm poking around to see if I can answer your call, and learn something myself.

Might this do the trick:

a.delete_if {|x| x % 2 == 0}

I realize this only handles deletes, but I think that's the only special case where you're running into the nil issue. Otherwise, the collect! method should work for other types of transformations...

Am hardly an expert, but these both achieve the same without the additional method:

(0..10).find_all {|x| x if x % 2 == 0}

(0..10).select {|x| x if x % 2 == 0}

you don't just want to select the values of course.

I'd probably do something like this:

(0..10).find_all {|x| x % 2 == 0}

Honestly, I consider list comprehensions to be one of the least elegant aspects of python--which says a lot about the overall elegance of the language I guess.

Ok, so I meant:

(0..10).find_all {|x| x % 2 != 0}

Thanks, all for the suggestions. I should have been more precise: I want to be able to do arbitrary tranformations in-line, too. More like the following python:

In [1]: [x*3 for x in range(10) if x%2 == 0]
Out[1]: [0, 6, 12, 18, 24]

Trying all of your suggestions above, I'm stuck with:

irb(main):015:0* (0..10).find_all {|x| x*3 if x%2 == 0}
=> [0, 2, 4, 6, 8, 10]
irb(main):016:0> (0..10).select {|x| x*3 if x%2 == 0}
=> [0, 2, 4, 6, 8, 10]
irb(main):017:0> (0..10).collect {|x| x*3 if x%2 == 0}
=> [0, nil, 6, nil, 12, nil, 18, nil, 24, nil, 30]
irb(main):018:0> (0..10).collect {|x| x*3 if x%2 == 0}.compact
=> [0, 6, 12, 18, 24, 30]

That's frustrating. Why aren't the values transforming with select and find_all? Is something wrong above? This is ruby-1.8.4, locally built on centos4-x86_64, fwiw.

I think what you want is something like:

(1..10).find_all {|x| x%2 == 0}.map {|x| x*3}

If you really want to find and map with one block you could roll it up yourself like this:

class Array
  def find_map
    return self unless block_given?
    result = []
    self.each do |i|
      r = yield i
      result << r unless r.nil?
    end
    result
  end
end

You have to add it to Range separately, but we can just pass the buck to the new Array method:

class Range
  def find_map
    return self.collect unless block_given?
    self.collect.find_map {|x| yield x}
  end
end

Now you can use find_map with an Array or a Range like so:

>> (1..10).find_map {|x| x*3 if x%2 == 0}
=> [6, 12, 18, 24, 30]
>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].find_map {|x| x*3 if x%2 == 0}
=> [6, 12, 18, 24, 30]

P.S. How do you do this insanely great code format preserving and syntax highlighting? It's fantastic!

Not sure what a range is in Python, but I'd say it is wrong. (Read on for why)

python: [x for x in range(10) if x % 2 == 0]
Out[1]: [0, 2, 4, 6, 8]

To get this same result for Ruby, it takes one more character
(notice the triple '...')

ruby: (0...10).select {|x| x if x % 2 == 0}
[0, 2, 4, 6, 8]

I would expect range to include both upper and lower bounds:
ruby: (0..10).select {|x| x if x % 2 == 0}
[0, 2, 4, 6, 8, 10]

The trouble with list comprehensions, IMO, is that they are special.
And what a silly name (IMO). Block are pervasive in Ruby.
Nothing special here. No extra brain power at all.

A simple 'ri Array' would have found the select method.
----------------------------------------------------------- Array#select
array.select {|item| block } -> an_array
------------------------------------------------------------------------
Invokes the block passing in successive elements from _array_,
returning an array containing those elements for which the block
returns a true value (equivalent to +Enumerable#select+).

a = %w{ a b c d e f }
a.select {|v| v =~ /[aeiou]/} #=> ["a", "e"]

Notice how you can expect Ruby to do the right thing and the iterator
treats the Range similar to an array.

The block passed to select needs to return a boolean, not a value.

>> (0..10).select {|x| x % 2 == 0}
=> [0, 2, 4, 6, 8, 10]

I see the selects being written here attempting to operate on the variable. If this does do anything, it will be in-place on the array (or range) that you're operating on. For an array, this is not really a problem, other than you probably didn't want to do that:

>> a = ('a'..'z').to_a
=> ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]
>> a.select do |l| l =~ /[aeiou]/ ? (l << '-mod'; l) : nil end 
=> ["a-mod", "e-mod", "i-mod", "o-mod", "u-mod"]
>> a
=> ["a-mod", "b", "c", "d", "e-mod", "f", "g", "h", "i-mod", "j", "k", "l", "m", "n", "o-mod", "p", "q", "r", "s", "t", "u-mod", "v", "w", "x", "y", "z"]

With a range, the outcome is different:

>> a = ('a'..'z')
=> "a".."z"
>> a.select do |l| l =~ /[aeiou]/ ? (l << '-mod'; l) : nil end
=> ["a-mod"]
>> a
=> "a-mod".."z"

If you want numeric iteration over a list, you first of all need a list!

>> r=[]; ('a'..'z').each {|v| r << v if v =~ /[aeiou]/}; r
=> ["a", "e", "i", "o", "u"]

>> y = []; for x in 0..10 do y << x * 3 if x % 2 == 0 end; y
=> [0, 6, 12, 18, 24, 30]

var = (y = []; for x in 0..10 do y << x * 3 if x % 2 == 0 end; y)

I have just learnt Ruby today so I may be wrong, but I would first filter with 'select' and then apply the function with 'collect':

(0..10).select {|x| (x%2) == 0 }.collect {|x| 3*x}
=> [0, 6, 12, 18, 24, 30]