Equivalent de Ruby Enumerable.collect qui retourne un Enumerable?

Question

Dans ce code, je crée un tableau de chaînes « 1 » à « 10000 »:

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

L'API Ruby Core fournit un moyen d'obtenir un objet dénombrable qui me permet d'énumérer sur la même liste, la génération les valeurs de chaîne à la demande, plutôt que de générer un tableau des chaînes?

Voici un autre exemple qui précise, espérons-ce que je suis en train de faire:

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

Où xform est la méthode que je cherche. awesome_names est un Enumerable, donc xform ne crée pas un tableau de chaînes de 1 million d'éléments, mais génère et retourne simplement des chaînes de la forme "hacker_ [N]" à la demande.

D'ailleurs, voici ce qu'il pourrait ressembler en C#:

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

(une solution)

Voici une extension recenseur qui ajoute une méthode xform. Il renvoie un autre énumérateur qui itère sur les valeurs de l'énumérateur d'origine, avec une transformation qui lui est appliquée.

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

Ruby 2.0 introduit Enumerable#lazy qui permet une chaîne à map, select, etc ..., et seulement générer les résultats finaux à la fin avec to_a, first, etc ... Vous pouvez l'utiliser dans n'importe quelle version Ruby avec 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' 

Sinon, vous pouvez utiliser Enumerator.new { with_a_block }. C'est nouveau dans Ruby 1.9, donc require 'backports/1.9.1/enumerator/new' si vous en avez besoin dans Ruby 1.8.x.

Comme par votre exemple, ce qui suit ne crée pas un tableau intermédiaire et ne construire les cordes nécessaires:

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 

Vous pouvez même remplacer les 100000 de 1,0/0 (Infinity), si vous voulez .

Pour répondre à votre commentaire, si vous mappez toujours vos valeurs un pour un, vous pourriez avoir quelque chose comme:

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

listes ont une chaque méthode:

(1..100000).each 

Answer 3

On dirait que vous voulez un objet recenseur, mais pas exactement.

En d'autres termes, un objet Enumérateur est un objet que vous pouvez utiliser pour appeler next à la demande (plutôt que each qui exécute la boucle entière). (Beaucoup de gens utilisent la langue interne par rapport itérateurs externes:.. each est interne, et un recenseur est externe Vous conduisez)

Voilà comment un recenseur pourrait ressembler:

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 

est ici un lien, à une discussion plus approfondie de la façon dont vous pouvez utiliser Ruby énumérateurs paresseusement: http://www.michaelharrison.ws/weblog/?p=163

Il y a aussi une section sur ce dans le livre Pioche (programmation Ruby par 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 prochaine chose à faire est de retourner un recenseur lorsqu'il est appelé sans bloc ...