Equivalente a Ruby Enumerable.collect que devuelve un Enumerable?

Question

En este código, puedo crear una matriz de cadenas "1" a "10000":

array_of_strings = (1..10000).collect {|i| String(i)} 

¿La API de Ruby Core proporciona una forma de obtener un objeto enumerable que me permite enumerar sobre la misma lista, generando los valores de cadena a pedido, en lugar de generar una matriz de cadenas?

Aquí está un ejemplo adicional que se espera aclara lo que estoy tratando de hacer:

def find_me_an_awesome_username 
    awesome_names = (1..1000000).xform {|i| "hacker_" + String(i) } 
    awesome_names.find {|n| not stackoverflow.userexists(n) } 
end 

Dónde xform es el método que yo estoy buscando. awesome_names es un enumerable, por lo que xform no crea una matriz de cadenas de elementos de un millón de unidades, sino que genera y devuelve cadenas de la forma "hacker_ [N]" a petición.

Por cierto, esto es lo que podría ser como en C#:

var awesomeNames = from i in Range(1, 1000000) select "hacker_" + i; 
var name = awesomeNames.First((n) => !stackoverflow.UserExists(n)); 

(una solución)

Aquí es una extensión al enumerador que añade un método xform. Devuelve otro enumerador que itera sobre los valores del enumerador original, con una transformación aplicada.

class Enumerator 
    def xform(&block) 
    Enumerator.new do |yielder| 
     self.each do |val| 
     yielder.yield block.call(val) 
     end 
    end 
    end 
end 

# this prints out even numbers from 2 to 10: 
(1..10).each.xform {|i| i*2}.each {|i| puts i} 

Answer 1

Rubí 2.0 introducido Enumerable#lazy que permite una a la cadena map, select, etc ..., y sólo generará los resultados finales al final con to_a, first, etc ... Puede usarlo en cualquier versión de Ruby con require 'backports/2.0.0/enumerable/lazy'.

require 'backports/2.0.0/enumerable/lazy' 
names = (1..Float::INFINITY).lazy.map{|i| "hacker_" + String(i) } 
names.first # => 'hacker_1' 

De lo contrario, puede utilizar Enumerator.new { with_a_block }. Es nuevo en Ruby 1.9, así que require 'backports/1.9.1/enumerator/new' si lo necesita en Ruby 1.8.x.

Como por su ejemplo, lo siguiente no crear una matriz intermedia y sólo construirá las cuerdas necesarias:

require 'backports/1.9.1/enumerator/new' 

def find_me_an_awesome_username 
    awesome_names = Enumerator.new do |y| 
    (1..1000000).each {|i| y.yield "hacker_" + String(i) } 
    end 
    awesome_names.find {|n| not stackoverflow.userexists(n) } 
end 

Usted puede incluso reemplazar el 100000 por 1,0/0 (es decir, Infinito), si quieres .

Para responder a su comentario, si siempre está correlacionando los valores de uno a uno, usted podría tener algo como:

module Enumerable 
    def lazy_each 
    Enumerator.new do |yielder| 
     each do |value| 
     yielder.yield(yield value) 
     end 
    end 
    end 
end 

awesome_names = (1..100000).lazy_each{|i| "hacker_#{i}"} 

Answer 2

listas tienen una cada método:

(1..100000).each 

Answer 3

Parece que usted desea que un objeto enumerador, pero no exactamente.

Es decir, un objeto enumerador es un objeto que se puede utilizar para llamar next a la carta (en lugar de each lo que hace todo el bucle). (Muchas personas utilizan el lenguaje de interno frente iteradores externos:.. each es interno, y un enumerador es externo Usted lo conduce)

Así es como un enumerador podría ser:

awesome_names = Enumerator.new do |y| 
    number = 1 
    loop do 
    y.yield number 
    number += 1 
    end 
end 

puts awesome_names.next 
puts awesome_names.next 
puts awesome_names.next 
puts awesome_names.next 

Aquí hay un enlace, a más discusión sobre cómo puede utilizar enumeradores perezosamente en Ruby: http://www.michaelharrison.ws/weblog/?p=163

también hay una sección sobre esto en el libro Pico (de programación Ruby por Dave Thomas).

Answer 4

class T < Range 
    def each 
    super { |i| yield String(i) } 
    end 
end 

T.new(1,3).each { |s| p s } 
$ ruby rsc.rb 
"1" 
"2" 
"3" 

La siguiente cosa que hacer es devolver un enumerador Cuando se invoca sin un bloque ...