From: Joshua Ballanco <jballanc@...>
Date: 2012-07-10T05:12:24+09:00
Subject: [ruby-core:46283] Re: Lambdaification of Method Calls

--4ffb3b1d_66334873_a614
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline

It seems to me that this is a bit like a combination of Proc#curry and a promise/future object. In fact, your second example can exactly be done with Proc#curry:

1.9.3-p194 :001 > s = "foo"
 => "foo" 
1.9.3-p194 :002 > l = s.method(:"+").to_proc.curry
 => #<Proc:0x007ffc83103c40 (lambda)> 
1.9.3-p194 :003 > l["end"]
 => "fooend" 
1.9.3-p194 :004 > s
 => "foo" 




On Monday, July 9, 2012 at 6:05 PM, Robert Klemme wrote:

> Hi,
> 
> does anybody think this is a good idea to have in stdlib or even core?
> 
> class Object
> def to_lambda(method, *a)
> lambda {|*b| send(method, *a, *b)}
> end
> end
> 
> With that we can do
> 
> irb(main):015:0> l = s.to_lambda(:<<, "<X>")
> => #<Proc:0x802c4298@(irb):12 (lambda)>
> irb(main):016:0> l.call
> => "foo<X>"
> irb(main):017:0> s
> => "foo<X>"
> irb(main):018:0> l[]
> => "foo<X><X>"
> irb(main):019:0> s
> => "foo<X><X>"
> 
> irb(main):038:0> s = "foo"
> => "foo"
> irb(main):039:0> l = s.to_lambda '+'
> => #<Proc:0x801e8d60@(irb):22 (lambda)>
> irb(main):040:0> l["end"]
> => "fooend"
> irb(main):041:0> s
> => "foo"
> 
> It would be a convenient way to bundle a method call with arguments
> for later execution (e.g. through a thread pool). You then just do
> 
> queue.enq my_object.to_lambda(:calculate, "foo", 123)
> 
> and be done. Another convenient name for the method would be "later".
> So we get
> 
> queue.enq my_object.later(:calculate, "foo", 123)
> 
> We could drive that even further and do
> 
> class Proc # or maybe class Object?
> def in(queue)
> queue << self
> end
> end
> 
> No we can do
> 
> my_object.later(:calculate, "foo", 123).in queue
> 
> Thoughts?
> 
> Kind regards
> 
> robert
> 
> -- 
> remember.guy do |as, often| as.you_can - without end
> http://blog.rubybestpractices.com/
> 
> 



--4ffb3b1d_66334873_a614
Content-Type: text/html; charset="utf-8"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: inline


                <div style=3D=22font-family: Helvetica; font-size: 13px; =
=22>It seems to me that this is a bit like a combination of Proc=23curry =
and a promise/future object. In fact, your second example can exactly be =
done with Proc=23curry:<div><br></div><div><div>1.9.3-p194 :001 &gt; s =3D=
 =22foo=22</div><div>&nbsp;=3D&gt; =22foo=22&nbsp;</div><div>1.9.3-p194 :=
002 &gt; l =3D s.method(:=22+=22).to=5Fproc.curry</div><div>&nbsp;=3D&gt;=
 =23&lt;Proc:0x007ffc83103c40 (lambda)&gt;&nbsp;</div><div>1.9.3-p194 :00=
3 &gt; l=5B=22end=22=5D</div><div>&nbsp;=3D&gt; =22fooend=22&nbsp;</div><=
div>1.9.3-p194 :004 &gt; s</div><div>&nbsp;=3D&gt; =22foo=22&nbsp;</div><=
/div></div>
                <div></div>
                =20
                <p style=3D=22color: =23A0A0A8;=22>On Monday, July 9, 201=
2 at 6:05 PM, Robert Klemme wrote:</p>
                <blockquote type=3D=22cite=22 style=3D=22border-left-styl=
e:solid;border-width:1px;margin-left:0px;padding-left:10px;=22>
                    <span><div><div><div>Hi,</div><div><br></div><div>doe=
s anybody think this is a good idea to have in stdlib or even core=3F</di=
v><div><br></div><div>class Object</div><div>  def to=5Flambda(method, *a=
)</div><div>    lambda =7B=7C*b=7C send(method, *a, *b)=7D</div><div>  en=
d</div><div>end</div><div><br></div><div>With that we can do</div><div><b=
r></div><div>irb(main):015:0&gt; l =3D s.to=5Flambda(:&lt;&lt;, =22&lt;X&=
gt;=22)</div><div>=3D&gt; =23&lt;Proc:0x802c4298=40(irb):12 (lambda)&gt;<=
/div><div>irb(main):016:0&gt; l.call</div><div>=3D&gt; =22foo&lt;X&gt;=22=
</div><div>irb(main):017:0&gt; s</div><div>=3D&gt; =22foo&lt;X&gt;=22</di=
v><div>irb(main):018:0&gt; l=5B=5D</div><div>=3D&gt; =22foo&lt;X&gt;&lt;X=
&gt;=22</div><div>irb(main):019:0&gt; s</div><div>=3D&gt; =22foo&lt;X&gt;=
&lt;X&gt;=22</div><div><br></div><div>irb(main):038:0&gt; s =3D =22foo=22=
</div><div>=3D&gt; =22foo=22</div><div>irb(main):039:0&gt; l =3D s.to=5Fl=
ambda '+'</div><div>=3D&gt; =23&lt;Proc:0x801e8d60=40(irb):22 (lambda)&gt=
;</div><div>irb(main):040:0&gt; l=5B=22end=22=5D</div><div>=3D&gt; =22foo=
end=22</div><div>irb(main):041:0&gt; s</div><div>=3D&gt; =22foo=22</div><=
div><br></div><div>It would be a convenient way to bundle a method call w=
ith arguments</div><div>for later execution (e.g. through a thread pool).=
  You then just do</div><div><br></div><div>queue.enq my=5Fobject.to=5Fla=
mbda(:calculate, =22foo=22, 123)</div><div><br></div><div>and be done.  A=
nother convenient name for the method would be =22later=22.</div><div> So=
 we get</div><div><br></div><div>queue.enq my=5Fobject.later(:calculate, =
=22foo=22, 123)</div><div><br></div><div>We could drive that even further=
 and do</div><div><br></div><div>class Proc =23 or maybe class Object=3F<=
/div><div>  def in(queue)</div><div>    queue &lt;&lt; self</div><div>  e=
nd</div><div>end</div><div><br></div><div>No we can do</div><div><br></di=
v><div>my=5Fobject.later(:calculate, =22foo=22, 123).in queue</div><div><=
br></div><div>Thoughts=3F</div><div><br></div><div>Kind regards</div><div=
><br></div><div>robert</div><div><br></div><div>-- </div><div>remember.gu=
y do =7Cas, often=7C as.you=5Fcan - without end</div><div><a href=3D=22ht=
tp://blog.rubybestpractices.com=22>http://blog.rubybestpractices.com</a>/=
</div></div></div></span>
                =20
                =20
                =20
                =20
                </blockquote>
                =20
                <div>
                    <br>
                </div>
            
--4ffb3b1d_66334873_a614--