# Help with tricky proc/binding issue **URL:** \ **Category:** ruby-talk\ **Created:** [19 September 2005 14:42 UTC](https://rubytalk.org/t/help-with-tricky-proc-binding-issue/20924 "2005-09-19T14:42:12Z")\ **Posts on this page:** 14\ **Page:** 1
**Author:** ![Ara.T.Howard6](https://avatars.discourse-cdn.com/v4/letter/a/958977/32.png) [@Ara.T.Howard6](https://rubytalk.org/u/Ara.T.Howard6)\ **Post date:** [19 September 2005 14:42 UTC](https://rubytalk.org/t/help-with-tricky-proc-binding-issue/20924/1 "2005-09-19T14:42:12Z")
i'm trying to be able to define a proc that can be called in the context of self, eg:    block = lambda{ p 42 }    an\_obj.instance\_eval &block but which can also be called with arguments, for example (imaginary ruby):    b = lambda{|x| p [x, y]}    class C      def y; 42; end    end    c = C::new    x = 42    c.arg\_instance\_eval(x, &b) #=\> [42, 42] any ideas? -a > **···** > > # -- > > > email :: ara [dot] t [dot] howard [at] noaa [dot] gov > > phone :: 303.497.6469 > > Your life dwells amoung the causes of death > > Like a lamp standing in a strong breeze. --Nagarjuna > > =============================================================================== ---
**Author:** ![Yukihiro\_Matsumoto2](https://avatars.discourse-cdn.com/v4/letter/y/b9e5f3/32.png) [@Yukihiro\_Matsumoto2](https://rubytalk.org/u/Yukihiro_Matsumoto2)\ **Post date:** [19 September 2005 14:54 UTC](https://rubytalk.org/t/help-with-tricky-proc-binding-issue/20924/2 "2005-09-19T14:54:27Z")
Hi, > **···** > > In message "Re: help with tricky proc/binding issue" on Mon, 19 Sep 2005 23:42:12 +0900, "Ara.T.Howard" \ writes: > > > i'm trying to be able to define a proc that can be called in the context of > > self, eg: > > > >   block = lambda{ p 42 } > >   an\_obj.instance\_eval &block > > > > but which can also be called with arguments, for example (imaginary ruby): > > I understand what you want. But I haven't come up with a good name > for the function yet. > >               matz. ---
**Author:** ![Robert](https://avatars.discourse-cdn.com/v4/letter/r/e95f7d/32.png) [@Robert](https://rubytalk.org/u/Robert)\ **Post date:** [19 September 2005 15:01 UTC](https://rubytalk.org/t/help-with-tricky-proc-binding-issue/20924/3 "2005-09-19T15:01:37Z")
Ara.T.Howard wrote: > i'm trying to be able to define a proc that can be called in the > context of self, eg: > >    block = lambda{ p 42 } >    an\_obj.instance\_eval &block > > but which can also be called with arguments, for example (imaginary > ruby): > >    b = lambda{|x| p [x, y]} > >    class C >      def y; 42; end >    end > >    c = C::new >    x = 42 > >    c.arg\_instance\_eval(x, &b) #=\> [42, 42] > > any ideas? The only workaround that comes to mind is to pass self explicitely along with other arguments. Or use a trick with delegation that allows to do instance\_eval on a proxy self that will also provide arguments given.     robert ---
**Author:** ![Pit](https://avatars.discourse-cdn.com/v4/letter/p/f14d63/32.png) [@Pit](https://rubytalk.org/u/Pit)\ **Post date:** [19 September 2005 15:39 UTC](https://rubytalk.org/t/help-with-tricky-proc-binding-issue/20924/4 "2005-09-19T15:39:42Z")
Ara.T.Howard schrieb: > i'm trying to be able to define a proc that can be called in the context of > self, eg: > >   block = lambda{ p 42 } >   an\_obj.instance\_eval &block > > but which can also be called with arguments, for example (imaginary ruby): > >   b = lambda{|x| p [x, y]} > >   class C >     def y; 42; end >   end > >   c = C::new >   x = 42 > >   c.arg\_instance\_eval(x, &b) #=\> [42, 42] > > any ideas? Tom (aka Trans) recently mentioned that he changed procs into methods in order to get what you want. Here's a quick hack, not efficient and not thread-safe, but maybe a start:    class Object      def arg\_instance\_eval( \*args, &block )        c = class \<\< self; self; end        c.send( :define\_method, :arg\_instance\_eval\_method, &block )        arg\_instance\_eval\_method( \*args )      ensure        c.send( :remove\_method, :arg\_instance\_eval\_method )      end    end    b = lambda{|x| p [x, y]}    class C      def y; 42; end    end    c = C::new    z = 41    c.arg\_instance\_eval( z, &b ) # =\> [41, 42] Regards, Pit ---
**Author:** ![Florian\_Gross2](https://avatars.discourse-cdn.com/v4/letter/f/b4bc9f/32.png) [@Florian\_Gross2](https://rubytalk.org/u/Florian_Gross2)\ **Post date:** [19 September 2005 15:41 UTC](https://rubytalk.org/t/help-with-tricky-proc-binding-issue/20924/5 "2005-09-19T15:41:22Z")
Ara.T.Howard wrote: > i'm trying to be able to define a proc that can be called in the context of > self, eg: > >   block = lambda{ p 42 } >   an\_obj.instance\_eval &block > > but which can also be called with arguments, for example (imaginary ruby): Currently the only way of doing this is Proc#self= from evil.rb... ---
**Author:** ![Ara.T.Howard6](https://avatars.discourse-cdn.com/v4/letter/a/958977/32.png) [@Ara.T.Howard6](https://rubytalk.org/u/Ara.T.Howard6)\ **Post date:** [19 September 2005 15:34 UTC](https://rubytalk.org/t/help-with-tricky-proc-binding-issue/20924/6 "2005-09-19T15:34:48Z")
maybe    class Object      def evaluate(\*args, &block)        ...      end    end ?? another option would be to turn the problem inside out and do something like    l = lambda{ p x }    l.self = obj    l.call this is what i have so far:    [ahoward@localhost ~]$ cat a.rb    class Object      def evaluate(\*a, &b)        m = "\_\_\_\_eval\_\_\_\_#{ rand(65536) }\_\_\_\_"        klass = Class === self ? self : self::class        klass.module\_eval{ define\_method m, &b }        begin          send m, \*a        ensure          klass.module\_eval{ remove\_method m }        end      end    end    class C      def y        42      end    end    b = lambda{|x| p [x, y, self]}    c = C::new    x = 42    c.evaluate(x, &b) #=\> [42, 42, #\]    [ahoward@localhost ~]$ ruby a.rb    [42, 42, #\] thoughts? -a > **···** > > On Mon, 19 Sep 2005, Yukihiro Matsumoto wrote: > > > Hi, > > > > In message "Re: help with tricky proc/binding issue" \> on Mon, 19 Sep 2005 23:42:12 +0900, "Ara.T.Howard" \ writes: > > > > \>i'm trying to be able to define a proc that can be called in the context of > > \>self, eg: > > \> > > \> block = lambda{ p 42 } > > \> an\_obj.instance\_eval &block > > \> > > \>but which can also be called with arguments, for example (imaginary ruby): > > > > I understand what you want. But I haven't come up with a good name > > for the function yet. > > # -- > > > email :: ara [dot] t [dot] howard [at] noaa [dot] gov > > phone :: 303.497.6469 > > Your life dwells amoung the causes of death > > Like a lamp standing in a strong breeze. --Nagarjuna > > =============================================================================== ---
**Author:** ![Florian\_Gross2](https://avatars.discourse-cdn.com/v4/letter/f/b4bc9f/32.png) [@Florian\_Gross2](https://rubytalk.org/u/Florian_Gross2)\ **Post date:** [19 September 2005 15:41 UTC](https://rubytalk.org/t/help-with-tricky-proc-binding-issue/20924/7 "2005-09-19T15:41:42Z")
Yukihiro Matsumoto wrote: > \>i'm trying to be able to define a proc that can be called in the context of > \>self, eg: > \> > \> block = lambda{ p 42 } > \> an\_obj.instance\_eval &block > \> > \>but which can also be called with arguments, for example (imaginary ruby): > > I understand what you want. But I haven't come up with a good name > for the function yet. What about Proc#with\_self() that will return a new proc similar to the current one, but with a changed self context? ---
**Author:** ![Robert](https://avatars.discourse-cdn.com/v4/letter/r/e95f7d/32.png) [@Robert](https://rubytalk.org/u/Robert)\ **Post date:** [19 September 2005 16:06 UTC](https://rubytalk.org/t/help-with-tricky-proc-binding-issue/20924/8 "2005-09-19T16:06:37Z")
Pit Capitain wrote: > Ara.T.Howard schrieb: > > > i'm trying to be able to define a proc that can be called in the > > context of self, eg: > > > >   block = lambda{ p 42 } > >   an\_obj.instance\_eval &block > > > > but which can also be called with arguments, for example (imaginary > > ruby): > > > >   b = lambda{|x| p [x, y]} > > > >   class C > >     def y; 42; end > >   end > > > >   c = C::new > >   x = 42 > > > >   c.arg\_instance\_eval(x, &b) #=\> [42, 42] > > > > any ideas? > > Tom (aka Trans) recently mentioned that he changed procs into methods > in order to get what you want. Here's a quick hack, not efficient and > not thread-safe, but maybe a start: > >    class Object >      def arg\_instance\_eval( \*args, &block ) >        c = class \<\< self; self; end >        c.send( :define\_method, :arg\_instance\_eval\_method, &block ) >        arg\_instance\_eval\_method( \*args ) >      ensure >        c.send( :remove\_method, :arg\_instance\_eval\_method ) >      end >    end Hacky but nice! For thread safety how about:    class Object      def arg\_instance\_eval( \*args, &block )        c = class \<\< self; self; end        meth = "\_\_m\_#{Thread.current.object\_id}\_#{rand 666}"        c.send( :define\_method, meth, &block )        send( meth, \*args )      ensure        c.send( :remove\_method, meth )      end    end Kind regards     robert ---
**Author:** ![Ara.T.Howard6](https://avatars.discourse-cdn.com/v4/letter/a/958977/32.png) [@Ara.T.Howard6](https://rubytalk.org/u/Ara.T.Howard6)\ **Post date:** [19 September 2005 16:10 UTC](https://rubytalk.org/t/help-with-tricky-proc-binding-issue/20924/9 "2005-09-19T16:10:53Z")
that's funny. here's my current hack:    class Object      def evaluate(\*a, &b)        ret, sent = nil        loop do          m = "\_\_\_\_evaluate\_\_\_\_#{ rand(42) }\_\_\_\_#{ rand(42) }\_\_\_\_"          klass = Class === self ? self : self::class          begin            klass.module\_eval{ define\_method m, &b }            ret = send(sent = m, \*a)          ensure            begin              klass.module\_eval{ remove\_method m }            ensure              break if sent            end          end        end        ret      end    end    class C      def y        42      end    end    b = lambda{|x| p [x, y, self]}    c = C::new    x = 42    c.evaluate(x, &b) #=\> [42, 42, #\] guess that's the way to go for now. cheers. -a > **···** > > On Tue, 20 Sep 2005, Pit Capitain wrote: > > > > any ideas? > > > > Tom (aka Trans) recently mentioned that he changed procs into methods in > > order to get what you want. Here's a quick hack, not efficient and not > > thread-safe, but maybe a start: > > > > class Object > >    def arg\_instance\_eval( \*args, &block ) > >      c = class \<\< self; self; end > >      c.send( :define\_method, :arg\_instance\_eval\_method, &block ) > >      arg\_instance\_eval\_method( \*args ) > >    ensure > >      c.send( :remove\_method, :arg\_instance\_eval\_method ) > >    end > > end > > > > b = lambda{|x| p [x, y]} > > > > class C > >    def y; 42; end > > end > > > > c = C::new > > z = 41 > > > > c.arg\_instance\_eval( z, &b ) # =\> [41, 42] > > # -- > > > email :: ara [dot] t [dot] howard [at] noaa [dot] gov > > phone :: 303.497.6469 > > Your life dwells amoung the causes of death > > Like a lamp standing in a strong breeze. --Nagarjuna > > =============================================================================== ---
**Author:** ![Florian\_Gross2](https://avatars.discourse-cdn.com/v4/letter/f/b4bc9f/32.png) [@Florian\_Gross2](https://rubytalk.org/u/Florian_Gross2)\ **Post date:** [19 September 2005 15:52 UTC](https://rubytalk.org/t/help-with-tricky-proc-binding-issue/20924/10 "2005-09-19T15:52:36Z")
Ara.T.Howard wrote: > another option would be to turn the problem inside out and do something like > >   l = lambda{ p x } >   l.self = obj >   l.call Procs are currently immutable and I'd assume that the source code assumes that they can not be changed in several places. It's less risky to return a new object with a changed self context, IMHO. ---
**Author:** ![Eric\_Mahurin1](https://avatars.discourse-cdn.com/v4/letter/e/34f0e0/32.png) [@Eric\_Mahurin1](https://rubytalk.org/u/Eric_Mahurin1)\ **Post date:** [19 September 2005 16:17 UTC](https://rubytalk.org/t/help-with-tricky-proc-binding-issue/20924/11 "2005-09-19T16:17:13Z")
I've talked about this before, but the ability to return a new proc with local variables manipulated would also be nice: - Make "local" variables really local to the proc. Initialize these to the current values of the local variables in the previous binding. Effectively, this gives the proc its own local binding (at least for "local" variables). This could be done in conjunction with redefining self for the proc to. It would also be nice to be able to be able to do the same thing for blocks easily so that you could easily localize your "local" variables in your block. But, you could emulate that as long as you had a way to localize proc local variables: foo(&(lambda{...}.localize)) or if you could do it directly to a block you may have some syntax like this: foo {{...}} # double braces to represent localization But, that has some conflicts with hash. Not sure of a good syntax. The problem is we can't apply methods directly to blocks - you have to convert to Proc, apply the method, and convert back. > **···** > > --- Florian Groß \ wrote: > > > Yukihiro Matsumoto wrote: > > > > \> \>i'm trying to be able to define a proc that can be called > > in the context of > > \> \>self, eg: > > \> \> > > \> \> block = lambda{ p 42 } > > \> \> an\_obj.instance\_eval &block > > \> \> > > \> \>but which can also be called with arguments, for example > > (imaginary ruby): > > \> > > \> I understand what you want. But I haven't come up with a > > good name > > \> for the function yet. > > > > What about Proc#with\_self() that will return a new proc > > similar to the > > current one, but with a changed self context? > > \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ > Do You Yahoo!? > Tired of spam? Yahoo! Mail has the best spam protection around > > > **[Yahoo Mail - Organized Email](https://mail.yahoo.com/)** > > > > It's time to get stuff done with Yahoo Mail. Just add your Gmail, Outlook, AOL or Yahoo Mail to get going. We automatically organize all the things life throws at you, like receipts and attachments, so you can find what you need fast. Plus, we've got... ---
**Author:** ![Ara.T.Howard6](https://avatars.discourse-cdn.com/v4/letter/a/958977/32.png) [@Ara.T.Howard6](https://rubytalk.org/u/Ara.T.Howard6)\ **Post date:** [19 September 2005 16:21 UTC](https://rubytalk.org/t/help-with-tricky-proc-binding-issue/20924/12 "2005-09-19T16:21:37Z")
^^^                                                         ^^^ lol! 😉 -a > **···** > > On Tue, 20 Sep 2005, Robert Klemme wrote: > > > Hacky but nice! For thread safety how about: > > > >   class Object > >     def arg\_instance\_eval( \*args, &block ) > >       c = class \<\< self; self; end > >       meth = "\_\_m\_#{Thread.current.object\_id}\_#{rand 666}" > > # -- > > > email :: ara [dot] t [dot] howard [at] noaa [dot] gov > > phone :: 303.497.6469 > > Your life dwells amoung the causes of death > > Like a lamp standing in a strong breeze. --Nagarjuna > > =============================================================================== ---
**Author:** ![Ara.T.Howard6](https://avatars.discourse-cdn.com/v4/letter/a/958977/32.png) [@Ara.T.Howard6](https://rubytalk.org/u/Ara.T.Howard6)\ **Post date:** [19 September 2005 16:21 UTC](https://rubytalk.org/t/help-with-tricky-proc-binding-issue/20924/13 "2005-09-19T16:21:37Z")
\ what i think to be the final version:    class Object      def evaluate(\*a, &b)        ret, sent = nil        loop do          m = "\_\_\_\_evaluate\_\_\_\_#{ Thread::current.object\_id }\_\_\_\_#{ rand 666 }\_\_\_\_#{ rand 42 }\_\_\_\_"          klass = Class === self ? self : self::class          begin            klass.module\_eval{ define\_method m, &b }            ret = send(sent = m, \*a)          ensure            begin              klass.module\_eval{ remove\_method m }            ensure              break if sent            end          end        end        ret      end    end    class C      def y        42      end    end    b = lambda{|x| p [x, y, self]}    c = C::new    x = 42    c.evaluate(x, &b) #=\> [42, 42, #\] -a > **···** > > On Tue, 20 Sep 2005, Robert Klemme wrote: > > > Hacky but nice! For thread safety how about: > > # -- > > > email :: ara [dot] t [dot] howard [at] noaa [dot] gov > > phone :: 303.497.6469 > > Your life dwells amoung the causes of death > > Like a lamp standing in a strong breeze. --Nagarjuna > > =============================================================================== ---
**Author:** ![Martin\_DeMello1](https://avatars.discourse-cdn.com/v4/letter/m/3be4f8/32.png) [@Martin\_DeMello1](https://rubytalk.org/u/Martin_DeMello1)\ **Post date:** [19 September 2005 16:06 UTC](https://rubytalk.org/t/help-with-tricky-proc-binding-issue/20924/14 "2005-09-19T16:06:37Z")
proc.bound\_to(object), perhaps. martin > **···** > > Florian Groß \ wrote: > > > Procs are currently immutable and I'd assume that the source code > > assumes that they can not be changed in several places. It's less risky > > to return a new object with a changed self context, IMHO.