Procs and Lambdas (1)

block在ruby里是一个词詓的概念，它不是对象，不能被对象操作，但是它能通过一个proc或者是一个lambda表现出来。Procs的行为像block（block-like behavior），lambdas的行为更像一个方法（method-like behavior）。但是两者都是Proc对象，这点可以通过使用class方法看出来。

创建Proc对象：

1,通过使用&前缀的方法参数创建一个proc

def makeproc(&p)  # Convert associated block to a Proc and store in p
  p               # Return the Proc object
end

adder = makeproc {|x,y| x+y }

sum = adder.call(2,2)  # => 4

 这种方式创建的Proc objects是proc，不是lambda，每一个Proc对象都有一个call方法，后面我们会看到多种call方法的语法糖。

2,使用Proc.new

  Proc.new创建的也是proc，而不是lambda，这是最常见的创建一个proc的方法

p = Proc.new {|x,y| x+y }

 这里有一个特殊的用法值得一提：

def invoke(&b)     def invoke
  b.call                  Proc.new.call
end                      end

 上面两个写法是一个效果，什么意思呢：

irb(main):001:1>def invoke
irb(main):002:1> Proc.new.call
irb(main):003:1> end
=> nil
irb(main):004:0> invoke { puts "hello"}
hello
=> nil

 3,Kernel.lambda

lambda是kernel模块的一个方法，所以它的行为像一个全局“函数”。由lambda创建的的Proc对象是一个lambda而不是proc :

is_positive = lambda {|x| x > 0 }

 在ruby1.8里面，Kernel.proc这个全局的proc方法是lambda方法的别名，它也返回一个lambda。ruby1.9修改了这一用法。1.9里proc是Proc.new的别名，因此，最好不要在1.8中使用proc这个全局的方法

irb(main):005:0> proc{ puts "a"}
=> #<Proc:0x8b91d44@(irb):5>
irb(main):006:0> ->{}
=> #<Proc:0x8b8ee64@(irb):6 (lambda)>

 lambda直接量：

1.9里出现了lambda直接量新的语法:

succ = ->(x){ x+1 }

succ.call(2)    # => 3

 lambda的参数作用域：

irb(main):017:0> x,y=1,2
=> [1, 2]
irb(main):018:0> f=->{puts x,y}
=> #<Proc:0x89929f8@(irb):18 (lambda)>
irb(main):019:0> f.call
1
2
=> nil
irb(main):020:0> p=->{x=11,y=22}
=> #<Proc:0x8989808@(irb):20 (lambda)>
irb(main):021:0> p.call
=> [11, 22]
irb(main):022:0> puts x,y
11
22
22
=> nil
#可以看出，lambda并没有象方法和类那样开辟了一个新的作用域，lambda周围
#的变量在lambda中是用定义的

 在ruby1.9里，你可以自行定义lambda的块级作用域，这些lambda的本地变量放在参数列表的“;”之后

irb(main):026:0> i=3
=> 3
irb(main):027:0> f=->(x,y;i,j,k){j=4;k=5;puts x,y,i,j,k}
=> #<Proc:0x88d03bc@(irb):27 (lambda)>
irb(main):028:0> f.call(1,2)
1
2
    #i ？
4
5
=> nil
irb(main):029:0> puts i,j,k
NameError: undefined local variable or method `j' for main:Object
	from (irb):29
	from /usr/local/bin/irb:12:in `<main>'

 lambda的更简洁的写法：

f = -> x,y; i,j,k { ... }
data.sort {|a,b| b-a }   # The block version
data.sort &->(a,b){ b-a } # The lambda literal version

 Procs和Lambdas的调用：

#使用call
f = Proc.new {|x,y| 1.0/(1.0/x + 1.0/y) }
z = f.call(x,y)
#用“[]”,有点像方法的调用方式
z = f[x,y]
#使用“.()”，看起来像是调用一个没有方法名的方法，“.()”不是一个操作符，不能被
#定义，它是call方法的一个语法糖。任何定义了call方法的对象都可以这样来调用call
#而不仅仅是Proc对象
z = f.(x,y)

irb(main):033:0> class A
irb(main):034:1> end
irb(main):036:0> a=A.new
=> #<A:0x8bc5108>
irb(main):037:0> def a.call str
irb(main):038:1> puts str
irb(main):039:1> end
=> nil
irb(main):040:0> a.("hello")
hello
=> nil

 Proc的目（参数个数）:arity方法的使用

lambda{||}.arity        # => 0. No arguments expected
lambda{|x| x}.arity     # => 1. One argument expected
lambda{|x,y| x+y}.arity # => 2. Two arguments expected

#对于下面这种情况,arity返回一个负数，通过~m（或者是-m-1）来计算这个
#lambda至少需要多少个参数
irb(main):043:0> ~-1
=> 0
irb(main):044:0> ~-2
=> 1

lambda {|*args|}.arity        # => -1.  ~-1 = -(-1)-1 = 0 arguments #required
lambda {|first, *rest|}.arity # => -2.  ~-2 = -(-2)-1 = 1 argument #required	  

 在ruby1.8和ruby1.9中，以下情况返回的值是不同的

puts lambda {}.arity  # –1 in Ruby 1.8; 0 in Ruby 1.9
#1.8里当lambda的参数列表为空表示它可以接受任意数目的参数，1.9里表示不接
#受任何带参数的调用，发生带参数调用时会出错
irb(main):046:0> l=->{puts "hello"}
=> #<Proc:0x8b8dfc8@(irb):46 (lambda)>
irb(main):047:0> l.("world")
ArgumentError: wrong number of arguments (1 for 0)
	from (irb):47:in `call'
	from (irb):47
	from /usr/local/bin/irb:12:in `<main>'

以上用法对于proc和lambda都适用，因为它们都是Proc对象，下面来看看Lambdas和Procs的区别