Höre auf faul aufzählbar

Question

Ich versuche, etwas zu bauen, das einen Ereignisstrom verarbeiten wird. Ich möchte, dass meine Prozessoren frei von Nebeneffekten sind, damit sie einfach zu verwalten sind, aber ich möchte auch sicherstellen, dass ich nicht zweimal durch den Stream laufe.

class A 
    def initialize(*processors) 
    @processors = processors 
    end 
    def call(list) 
    @processors.inject(0) { |acc, p| 
     acc + p.call(list) 
    } 
    end 
end 

class B 
    def initialize(multiplier) 
    @multiplier = multiplier 
    end 

    def call(list) 
    list.map { |i| 
     i * @multiplier 
    }.inject(0) { |acc, i| 
     puts "B with multipler: #{@multiplier}, adding: #{i}" 
     acc + i 
    } 
    end 
end 

A.new(B.new(1), B.new(2)).call([1, 2, 3, 4, 5].lazy) 
# => 45 

Klasse A ist völlig falsch, wie die Ausführungsreihenfolge ist:

# B with multipler: 1, adding: 1 
# B with multipler: 1, adding: 2 
# B with multipler: 1, adding: 3 
# B with multipler: 1, adding: 4 
# B with multipler: 1, adding: 5 
# B with multipler: 2, adding: 2 
# B with multipler: 2, adding: 4 
# B with multipler: 2, adding: 6 
# B with multipler: 2, adding: 8 
# B with multipler: 2, adding: 10 

Wie ich Klasse A ändern könnte mir eine Ausführungsreihenfolge zu geben:

# B with multipler: 1, adding: 1 
# B with multipler: 2, adding: 2 
# B with multipler: 1, adding: 2 
# B with multipler: 2, adding: 4 
# B with multipler: 1, adding: 3 
# B with multipler: 2, adding: 6 
# B with multipler: 1, adding: 4 
# B with multipler: 2, adding: 8 
# B with multipler: 1, adding: 5 
# B with multipler: 2, adding: 10 

Muss ich einige brauchen Art von anspruchsvolleren aufzählbar?

Answer 1

Wenn Sie Prozessoren auf Werte um anwenden möchten müssen Sie sie einer nach dem anderen

class A 
    def initialize(*processors) 
    @processors = processors 
    end 
    def call(list) 
    list.inject(0) do |acc, item| 
     acc + @processors.map { |processor| processor.call(item) }.inject(:+) 
    end 
    end 
end 

class B 
    def initialize(multiplier) 
    @multiplier = multiplier 
    end 

    def call(item) 
    puts "B with multipler: #{@multiplier}, adding: #{item}" 
    item * @multiplier 
    end 
end 

p A.new(B.new(1), B.new(2)).call([1, 2, 3, 4, 5].lazy) 

senden