[lnkForumImage]
TotalShareware - Download Free Software
Confronta i prezzi di migliaia di prodotti.
Asp Forum
 Home | Login | Register | Search 


 

Forums >

comp.lang.ruby

Higher order ruby

zslevi

1/14/2009 10:07:00 AM

foo = lambda {|x| lambda {|y| return x+y}}

foo.call(3)(4)

Why this doesn't work? I expected lamdas to behave like in SML.
12 Answers

zslevi

1/14/2009 10:10:00 AM

0

I even tried

foo = lambda {|x| lambda return {|x,y| return x+y}}

(foo.call(3)).call(4)

But it doesn't work either.

Jesús Gabriel y Galán

1/14/2009 10:13:00 AM

0

On Wed, Jan 14, 2009 at 11:09 AM, zslevi <zslevi@gmail.com> wrote:
> foo = lambda {|x| lambda {|y| return x+y}}
>
> foo.call(3)(4)
>
> Why this doesn't work? I expected lamdas to behave like in SML.

When you call foo, or apply it with [], you get another lambda in return.
To call that lambda you have to use call again, or []:

irb(main):001:0> foo = lambda {|x| lambda {|y| return x+y}}
=> #<Proc:0xb7bb5f28@(irb):1>
irb(main):002:0> foo[3][4]
=> 7
irb(main):003:0> foo.call(3).call(4)
=> 7

Jesus.

LAMBEAU Bernard

1/14/2009 10:14:00 AM

0

foo.call(3).call(4) should work

blambeau

On Wed, Jan 14, 2009 at 11:09 AM, zslevi <zslevi@gmail.com> wrote:
> foo = lambda {|x| lambda {|y| return x+y}}
>
> foo.call(3)(4)
>
> Why this doesn't work? I expected lamdas to behave like in SML.
>
>

zslevi

1/14/2009 10:14:00 AM

0

foo = lambda {|x|
return lambda {|y| return x+y}}

puts (foo.call(3)).call(4)

It works finally, but it's just too verbose.
Can anyone suggest a shorter, programmer friendlier way of writing
this?

Brian Candler

1/14/2009 10:20:00 AM

0

zslevi wrote:
> foo = lambda {|x|
> return lambda {|y| return x+y}}
>
> puts (foo.call(3)).call(4)
>
> It works finally, but it's just too verbose.
> Can anyone suggest a shorter, programmer friendlier way of writing
> this?

foo[3][4] as shown above. And you don't need 'return' inside the lambda.

foo = lambda {|x| lambda {|y| x+y}}
foo[3][4]
--
Posted via http://www.ruby-....

Jesús Gabriel y Galán

1/14/2009 10:35:00 AM

0

On Wed, Jan 14, 2009 at 11:14 AM, zslevi <zslevi@gmail.com> wrote:
> foo = lambda {|x|
> return lambda {|y| return x+y}}
>
> puts (foo.call(3)).call(4)
>
> It works finally, but it's just too verbose.
> Can anyone suggest a shorter, programmer friendlier way of writing
> this?

As said before you don't need the returns, and you don't need so many
parentheses.
Can you let us know if this works for you?

irb(main):004:0> foo = lambda {|x| lambda {|y| x + y}}
=> #<Proc:0xb7b9c758@(irb):4>
irb(main):005:0> foo.call(3).call(4)
=> 7
irb(main):006:0> puts foo.call(3).call(4)
7
=> nil
irb(main):007:0> puts foo[3][4]
7
=> nil

Jesus.

pjb

1/14/2009 11:17:00 AM

0

zslevi <zslevi@gmail.com> writes:

> foo = lambda {|x|
> return lambda {|y| return x+y}}
>
> puts (foo.call(3)).call(4)
>
> It works finally, but it's just too verbose.
> Can anyone suggest a shorter, programmer friendlier way of writing
> this?

What about:

irb(main):038:0> (foo = (lambda {|x| (lambda {|y| (x + y)})}))
#<Proc:0x00007f797ea420f0@(irb):38>
irb(main):039:0> (funcall (funcall foo,3),4)
7

(See the "functional programming" thread).

or you could write:

(def uncurry(f,arg)
(funcall f,arg)
end)

and then:

(uncurry (uncurry foo,3),4)

--
__Pascal Bourguignon__

ThoML

1/14/2009 11:29:00 AM

0

On Jan 14, 11:09=A0am, zslevi <zsl...@gmail.com> wrote:
> foo =3D lambda {|x| lambda {|y| return x+y}}
>
> foo.call(3)(4)

In ruby 1.9, you could also do:
foo.(3).(4)

You also have a curry method:

bar =3D lambda {|x,y| x + y}
bar.curry[3].(4)

-tom

William James

1/15/2009 10:53:00 AM

0

zslevi wrote:

> foo = lambda {|x|
> return lambda {|y| return x+y}}
>
> puts (foo.call(3)).call(4)
>
> It works finally, but it's just too verbose.
> Can anyone suggest a shorter, programmer friendlier way of writing
> this?

Can you see that "proc" is shorter than "lambda"?

foo = proc{|x| proc{|y| x+y}}
==>#<Proc:0x02824eb4@(irb):20>
foo[3][4]
==>7

André Thieme

1/18/2009 2:42:00 AM

0

William James schrieb:
> zslevi wrote:
>
>> foo = lambda {|x|
>> return lambda {|y| return x+y}}
>>
>> puts (foo.call(3)).call(4)
>>
>> It works finally, but it's just too verbose.
>> Can anyone suggest a shorter, programmer friendlier way of writing
>> this?
>
> Can you see that "proc" is shorter than "lambda"?
>
> foo = proc{|x| proc{|y| x+y}}
> ==>#<Proc:0x02824eb4@(irb):20>
> foo[3][4]
> ==>7

Javascript:
3+4


André
--