Why none of the block giving the expected output with the "enumerator"?

ruby-talk
1

Why none of the block giving the expected output with the "enumerator"?

···

=======================================================================
irb(main):017:0> a=[11,22,31,224,44].to_enum
=> #<Enumerator: [11, 22, 31, 224, 44]:each>
irb(main):018:0> a.each{|x| x%2 == 0}
=> [11, 22, 31, 224, 44]
irb(main):019:0> a.each{|x| x%4 == 0}
=> [11, 22, 31, 224, 44]
irb(main):020:0> a.each{|x| x > 22 }
=> [11, 22, 31, 224, 44]
irb(main):021:0> a.each{|x,y| x-y }
TypeError: nil can't be coerced into Fixnum
        from (irb):21:in `-'
        from (irb):21:in `block in irb_binding'
        from (irb):21:in `each'
        from (irb):21:in `each'
        from (irb):21
        from C:/Ruby193/bin/irb:12:in `<main>'
irb(main):022:0> a.each{|x,y| (x-y) }
TypeError: nil can't be coerced into Fixnum
        from (irb):22:in `-'
        from (irb):22:in `block in irb_binding'
        from (irb):22:in `each'
        from (irb):22:in `each'
        from (irb):22
        from C:/Ruby193/bin/irb:12:in `<main>'
irb(main):023:0>

--
Posted via http://www.ruby-forum.com/.

2

You create an enumerator from an array. When the enumerator's each method is
called, it'll call the array's each method, which calls the block for every
element and returns the array itself.

In your first example, you execute the expression x%2==0 for each element, but
you do nothing for the result. If you want to display the result, you'll need
something like

a.each{|x| puts(x%2==0)}

If you want to select only those elements you'll want to use Enumerable#select
rather than Enumerable#each:

a1 = a.select{|x| x%2==0}

I hope this helps

Stefano

···

On Sunday 03 February 2013 Arup Rakshit wrote

Why none of the block giving the expected output with the "enumerator"?

=======================================================================
irb(main):017:0> a=[11,22,31,224,44].to_enum
=> #<Enumerator: [11, 22, 31, 224, 44]:each>
irb(main):018:0> a.each{|x| x%2 == 0}
=> [11, 22, 31, 224, 44]
irb(main):019:0> a.each{|x| x%4 == 0}
=> [11, 22, 31, 224, 44]
irb(main):020:0> a.each{|x| x > 22 }
=> [11, 22, 31, 224, 44]
irb(main):021:0> a.each{|x,y| x-y }
TypeError: nil can't be coerced into Fixnum
        from (irb):21:in `-'
        from (irb):21:in `block in irb_binding'
        from (irb):21:in `each'
        from (irb):21:in `each'
        from (irb):21
        from C:/Ruby193/bin/irb:12:in `<main>'
irb(main):022:0> a.each{|x,y| (x-y) }
TypeError: nil can't be coerced into Fixnum
        from (irb):22:in `-'
        from (irb):22:in `block in irb_binding'
        from (irb):22:in `each'
        from (irb):22:in `each'
        from (irb):22
        from C:/Ruby193/bin/irb:12:in `<main>'
irb(main):023:0>

--
Posted via http://www.ruby-forum.com/\.

3

Why none of the block giving the expected output with the "enumerator"?

They do, you have wrong expectations. (You really should read the docs
and google for examples/tutorials/... to build the right expectations.)

(BTW, next time please *tell us* what your expected output would have
  been.)

=======================================================================
irb(main):017:0> a=[11,22,31,224,44].to_enum
=> #<Enumerator: [11, 22, 31, 224, 44]:each>
irb(main):018:0> a.each{|x| x%2 == 0}
=> [11, 22, 31, 224, 44]
irb(main):019:0> a.each{|x| x%4 == 0}
=> [11, 22, 31, 224, 44]
irb(main):020:0> a.each{|x| x > 22 }
=> [11, 22, 31, 224, 44]

First, you do not need to_enum here, simply use Array#each.

Second, the blocks behave exactly as should be expected.

What you probably meant was something like

   1.9.3-p194 :001 > a = [11, 22, 31, 224, 44]
    => [11, 22, 31, 224, 44]
   1.9.3-p194 :002 > a.each {|item| puts item if item % 2 == 0 }
   22
   224
   44
    => [11, 22, 31, 224, 44]

You did not 'do' anything with the logical expression inside the block.

What you probably misinterpreted as the output (the part after '=>')
is actually the value of the evaluated expresssion, which in this case
is the return value of the each method (-> the array itself, see docs).
Besides the output generated by puts statements etc., irb always
additionally outputs the value of the evaluated expression.

irb(main):021:0> a.each{|x,y| x-y }
TypeError: nil can't be coerced into Fixnum
         from (irb):21:in `-'
         from (irb):21:in `block in irb_binding'
         from (irb):21:in `each'
         from (irb):21
         from C:/Ruby193/bin/irb:12:in `<main>'

This cannot work, because #each yields exactly one parameter (see docs).
y therefore always is nil and nil cannot be subtracted from x.

···

Am 02.02.2013 21:20, schrieb Arup Rakshit:

--
<https://github.com/stomar/&gt;

4

Stefano Crocco wrote in post #1094918:

···

On Sunday 03 February 2013 Arup Rakshit wrote

=> [11, 22, 31, 224, 44]
        from (irb):22:in `-'
        from (irb):22:in `block in irb_binding'
        from (irb):22:in `each'
        from (irb):22:in `each'
        from (irb):22
        from C:/Ruby193/bin/irb:12:in `<main>'
irb(main):023:0>

@Stefano why is it calling Array's "each" method,instead of
"enum#each",as i converted it to enumerator?

thanks

--
Posted via http://www.ruby-forum.com/\.

5

unknown wrote in post #1094928:

···

Am 02.02.2013 21:20, schrieb Arup Rakshit:

What you probably misinterpreted as the output (the part after '=>')
is actually the value of the evaluated expresssion, which in this case
is the return value of the each method (-> the array itself, see docs).
Besides the output generated by puts statements etc., irb always
additionally outputs the value of the evaluated expression.

irb(main):021:0> a.each{|x,y| x-y }
TypeError: nil can't be coerced into Fixnum
         from (irb):21:in `-'
         from (irb):21:in `block in irb_binding'
         from (irb):21:in `each'
         from (irb):21:in `each'
         from (irb):21
         from C:/Ruby193/bin/irb:12:in `<main>'

This cannot work, because #each yields exactly one parameter (see docs).
y therefore always is nil and nil cannot be subtracted from x.

`+1` to you. You guided me perfectly! :slight_smile:

--
Posted via http://www.ruby-forum.com/\.

6

Because Enumerator#each, in turn, calls the each method of the object it was
created from.

It is (more or less) if the enumerator was created this way:

class Enumerator

  def initialize object, method = :each
    @object = object
    @method = method
    @args = args
  end

  def each
    @object.send :method, *args
  end

end

Actually, Enumerator is written in C, so its implementation is different from
this.

So, when you create an enumerator from an array, the #each method of the
Enumerator calls the #each method of the array.

Stefano

···

On Sunday 03 February 2013 Arup Rakshit wrote

Stefano Crocco wrote in post #1094918:
> On Sunday 03 February 2013 Arup Rakshit wrote
>
>> => [11, 22, 31, 224, 44]
>>
>> from (irb):22:in `-'
>> from (irb):22:in `block in irb_binding'
>> from (irb):22:in `each'
>> from (irb):22:in `each'
>> from (irb):22
>> from C:/Ruby193/bin/irb:12:in `<main>'
>>
>> irb(main):023:0>

@Stefano why is it calling Array's "each" method,instead of
"enum#each",as i converted it to enumerator?

thanks

--
Posted via http://www.ruby-forum.com/\.

7

Stefano Crocco wrote in post #1094920:

···

On Sunday 03 February 2013 Arup Rakshit wrote

@Stefano ->

Could you simulate the same example with the enum#each method, just to
understand the difference between enum#each and array#each?

Thanks

--
Posted via http://www.ruby-forum.com/\.

8

Again, there's no difference, since Enumerator#each (when the Enumerator was
created from an array) calls Array.each.

To clarify things, imagine we create a new class, MyArray, which contains an
array (to make things simple, we pass the array to the constructor). This
class has an #each method which takes a block (using the &blk syntax), then
displays the text "Calling MyArray#each", then calls the #each method of the
internal array:

class MyArray

  def initialize a
    @array = a
  end
  
  def each &blk
    puts "Calling MyArray#each"
    @array.each &blk
  end
  
end

Now, we create an instance of MyArray, and create an enumerator from it.

ma = MyArray.new [1,2,3,4,5]
e = ma.to_enum

Now, try calling the each method once on ma and once on e, and you'll see that
they produce the same output:

ma.each{|i| puts i}
e.each{|i| puts i}

In both cases, the output is:

Calling MyArray#each
1
2
3
4
5
=> [1, 2, 3, 4, 5]

As you can see, there's no difference between the two calls.

Stefano

···

On Sunday 03 February 2013 Arup Rakshit wrote

Stefano Crocco wrote in post #1094920:
> On Sunday 03 February 2013 Arup Rakshit wrote

@Stefano ->

Could you simulate the same example with the enum#each method, just to
understand the difference between enum#each and array#each?

Thanks

--
Posted via http://www.ruby-forum.com/\.

9

Stefano Crocco wrote in post #1094924:

···

On Sunday 03 February 2013 Arup Rakshit wrote

@Stefano

Perfect explanation and I understood. What I meant is that to give an
example which will call and work as enum#each.

Thanks

--
Posted via http://www.ruby-forum.com/\.