Getting an Error with local variable

class String
  remove_method(:each)
end

class Object
  def reach
    if(x.respond_to?(:each))
      self.each{|x| x.reach(yield)}
    else
      yield(self)
    end
  end
end

This is my code.. I keep getting the error that it can't find the local
variable 'x' .... why???

···

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

Hi, Cheryl

   if(x.respond_to?(:each))

x is not defined here.
This is not x but self, isn't it?

The following code works well.

class String
remove_method(:each)
end

class Object
def reach
   if(self.respond_to?(:each)) # <<<
     self.each{|x| x.reach(yield)}
   else
     yield(self)
   end
end
end

"hoge".reach { |myself|
print myself
}

···

--
Haruka YAGNI
hyagni@gmail.com

Because you use x here:

   if(x.respond_to?(:each))

But it hasn't been defined.

You probably just want to remove that x.

now im getting the error:

multiple values for the block paramater(0 for 1)

···

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

multiple values for the block paramater(0 for 1)

You cannot set an argument for x.reach.
  self.each{|x| x.reach(yield)}

Instead,
  self.each{|x| x.reach{|y| yield y}}
This works but is not elegant.
Somebody has an idea?

···

--
Haruka YAGNI
hyagni@gmail.com

The approach is broken because the block is not carried through the
recursion. Please see my recent reply in thread "Creating a Reach
Program" a few days back. Cheryl, did you actually read it?

robert

···

On Wed, Mar 30, 2011 at 5:00 AM, Haruka YAGNI <hyagni@gmail.com> wrote:

multiple values for the block paramater(0 for 1)

You cannot set an argument for x.reach.
self.each{|x| x.reach(yield)}

Instead,
self.each{|x| x.reach{|y| yield y}}
This works but is not elegant.
Somebody has an idea?

--
remember.guy do |as, often| as.you_can - without end
http://blog.rubybestpractices.com/

Robert, thank you for the reply.

self.each{|x| x.reach{|y| yield y}}
This works but is not elegant.
Somebody has an idea?

The approach is broken because the block is not carried through the
recursion.

I read your previous post. I like it.
It is elegant to useblock instead of yield and to add reach method to
Enumerable module.

I am curious about when my code does not work.
I tested the next script and it printed the same as your code.

class String
remove_method(:each)
end

class Object
def reach
   if(self.respond_to?(:each))
     self.each{|x| x.reach{|y| yield y}}
   else
     yield(self)
   end
end
end

[["hoge", "huga"],["foo", "bar"]].reach { |myself|
print myself
}

With a nested array, a new block is given to the next 'reach'.
So, I think, if I write this without recursion (of course impossible),
the whole prosess is like
   some_array.each{|x1| x1.each{|x2| x2.each{ .... xn.each {|myself|
print myself} ....}}}
and xn is an unnested array.

If I misunderstand something, or my program has a bug, please let me know.

Thanks.

Haruka YAGNI

···

On Wed, Mar 30, 2011 at 7:59 PM, Robert Klemme <shortcutter@googlemail.com> wrote:

This is only needed in 1.8.* btw.

$ allruby -e 'String.instance_method "each"'
CYGWIN_NT-5.1 padrklemme2 1.7.9(0.237/5/3) 2011-03-29 10:10 i686 Cygwin

···

On Wed, Mar 30, 2011 at 2:14 PM, Haruka YAGNI <hyagni@gmail.com> wrote:

Robert, thank you for the reply.

On Wed, Mar 30, 2011 at 7:59 PM, Robert Klemme > <shortcutter@googlemail.com> wrote:

self.each{|x| x.reach{|y| yield y}}
This works but is not elegant.
Somebody has an idea?

The approach is broken because the block is not carried through the
recursion.

I read your previous post. I like it.
It is elegant to useblock instead of yield and to add reach method to
Enumerable module.

I am curious about when my code does not work.
I tested the next script and it printed the same as your code.

class String
remove_method(:each)
end

========================================
ruby 1.8.7 (2008-08-11 patchlevel 72) [i386-cygwin]

ruby 1.9.2p180 (2011-02-18 revision 30909) [i386-cygwin]
-e:1:in `instance_method': undefined method `each' for class `String'
(NameError)
        from -e:1:in `<main>'

jruby 1.6.0 (ruby 1.8.7 patchlevel 330) (2011-03-15 f3b6154) (Java
HotSpot(TM) Client VM 1.6.0_24) [Windows XP-x86-java]

jruby 1.6.0 (ruby 1.9.2 patchlevel 136) (2011-03-15 f3b6154) (Java
HotSpot(TM) Client VM 1.6.0_24) [Windows XP-x86-java]
NameError: undefined method `each' for class `String'
  instance_method at org/jruby/RubyModule.java:1957
           (root) at -e:1

class Object
def reach
if(self.respond_to?(:each))
self.each{|x| x.reach{|y| yield y}}
else
yield(self)
end
end
end

[["hoge", "huga"],["foo", "bar"]].reach { |myself|
print myself
}

With a nested array, a new block is given to the next 'reach'.
So, I think, if I write this without recursion (of course impossible),
the whole prosess is like
some_array.each{|x1| x1.each{|x2| x2.each{ .... xn.each {|myself|
print myself} ....}}}
and xn is an unnested array.

If I misunderstand something, or my program has a bug, please let me know.

I'm afraid the bug is in my brain. You are right. I am sorry. I
should have taken more time to look at this.

That approach does produce awful call stacks though (with multiple
levels of nesting the call chain has to go backwards up to the topmost
caller to invoke the block initially provided to reach; you can see
this by adding "puts caller" to the beginning of the block). I find it
more elegant to pass the block down and have it invoked immediately.
Apparently you agree with me here.

Kind regards

robert

--
remember.guy do |as, often| as.you_can - without end
http://blog.rubybestpractices.com/

Robert, thank you for the reply.

self.each{|x| x.reach{|y| yield y}}
This works but is not elegant.
Somebody has an idea?

The approach is broken because the block is not carried through the
recursion.

I read your previous post. I like it.
It is elegant to useblock instead of yield and to add reach method to
Enumerable module.

I am curious about when my code does not work.
I tested the next script and it printed the same as your code.

class String
remove_method(:each)
end

I'm afraid the bug is in my brain. You are right. I am sorry. I
should have taken more time to look at this.

No problem at all.

That approach does produce awful call stacks though (with multiple
levels of nesting the call chain has to go backwards up to the topmost
caller to invoke the block initially provided to reach; you can see
this by adding "puts caller" to the beginning of the block). I find it
more elegant to pass the block down and have it invoked immediately.
Apparently you agree with me here.

Yes, I agree at all points.
When I do something like this in my application, I will use your
solution with appreciation.

Thank you for you kind information.

regards

Haruka YAGNI

···

On Wed, Mar 30, 2011 at 9:36 PM, Robert Klemme <shortcutter@googlemail.com> wrote:

On Wed, Mar 30, 2011 at 2:14 PM, Haruka YAGNI <hyagni@gmail.com> wrote:

On Wed, Mar 30, 2011 at 7:59 PM, Robert Klemme >> <shortcutter@googlemail.com> wrote: