何时何地使用 Lambda？

Question

我试图理解为什么我们真的需要 ruby​​ 中的 lambda 或 proc（或任何其他语言）？

#method
def add a,b
  c = a+b
end

#using proc
def add_proc a,b
  f = Proc.new {|x,y| x + y }
  f.call a,b
end

#using lambda function
def add_lambda a,b
  f = lambda {|x,y| x + y}
  f.call a,b
end

puts add 1,1
puts add_proc 1,2
puts add_lambda 1,3

我可以使用以下方法进行简单的加法：1. 普通函数 def，2. 使用 proc，3. 使用 lambda。

但在现实世界中为什么以及在哪里使用 lambda 呢？任何不能使用函数而应使用 lambda 的示例。

Answer 1

确实，您不需要匿名函数（或 lambda，或任何您想称呼的名称）。但有很多东西你并不需要。您不需要类，只需将所有实例变量传递给普通函数即可。然后

class Foo
  attr_accessor :bar, :baz
  def frob(x)
    bar = baz*x
  end
end

会变成

def new_Foo(bar,baz)
  [bar,baz]
end

def bar(foo)
  foo[0]
end
# Other attribute accessors stripped for brevity's sake

def frob(foo,x)
  foo[0] = foo[1]*x
end

类似地，除了带有 if 和 break 的 loop...end 之外，您不需要需要任何循环>。我可以继续说下去。¹但是您想要使用 Ruby 中的类进行编程。您希望能够使用while循环，甚至array.each { |x| ... }，并且您希望能够使用 unless 而不是 if not。

就像这些功能一样，匿名函数可以帮助您优雅、简洁、明智地表达事物。能够编写 some_function(lambda { |x,y| x + f(y) }) 比必须编写要好得多，

def temp(x,y)
  x + f(y)
end
some_function temp

必须中断代码流才能写出要麻烦得多一个 deffed 函数，当它可以清晰地内联编写操作时，必须给它一个无用的名称。确实，没有地方必须使用 lambda，但有很多地方宁愿使用 lambda。

Ruby 通过块解决了许多使用 lambda 的情况：所有函数，如 each、map 和 open 都可以将块作为参数基本上采用特殊情况的匿名函数。 array.map { |x| f(x) + g(x) } 与 array.map(&lambda { |x| f(x) + g(x) }) 相同（其中& 只是让 lambda 变得“特殊”，就像裸块一样）。同样，您可以每次都编写一个单独的deffed 函数，但您为什么想要这样做呢？

除了 Ruby 之外，支持这种编程风格的语言没有块，但通常支持更轻量级的 lambda 语法，例如 Haskell 的 \x -> fx + g x，或 C# 的 x => f(x) + g(x);²。任何时候我有一个函数需要采取一些抽象行为，例如 map、each 或 on_clicked，我都会感谢能够传入 lambda 而不是命名函数，因为它更容易。最终，您不再认为它们有什么特殊之处，它们与数组的文字语法一样令人兴奋，而不是 empty().append(1).append(2).append(3)。这只是该语言的另一个有用的部分。

---

1：在退化情况下，您实际上只需要八条指令： +-<>[].,。 <> 沿着数组移动一个假想的“指针”； +- 递增和递减当前单元格中的整数； [] 执行非零循环；和 ., 进行输入和输出。事实上，您实际上只需要一条指令，例如subleq ab c （从 b 中减去 a，如果结果小于或等于 0，则跳转到 c）。

2：我从未真正使用过 C#，因此如果该语法错误，请随时更正。

Answer 2

块或多或少是同一件事

，在 Ruby 中，人们通常不使用 lambda 或 proc，因为块是同一件事，而且更方便。

用途是无限的，但我们可以列出一些典型案例。人们通常将函数视为执行一部分处理的较低级块，可能通常编写并制成库。

但人们经常希望自动化包装器并提供自定义库。想象一个函数建立 HTTP 或 HTTPS 连接，或者直接 TCP 连接，将 I/O 提供给其客户端，然后关闭连接。或者也许只是对普通的旧文件执行相同的操作。

因此，在 Ruby 中，我们会将函数放入库中，并让它为用户.. 客户端.. “调用者”占用一个块来编写他的应用程序逻辑。

在另一种语言中，这必须通过实现接口或函数指针的类来完成。 Ruby 有块，但它们都是 lambda 风格设计模式的示例。

Answer 3

1. 这只是一个方便。您不需要命名某些块

   special_sort(array, :compare_proc => lambda { |left, right| left.special_param <=> right.special_param }

(想象一下，如果您必须命名所有这些块)

2. #lambda 通常用于创建闭包：

   defgenerate_multiple_proc(辅因子)
   lambda { |元素|元素 * 辅因子 }
   结束

   [1, 2, 3, 4].map(&generate_multiple_proc(2)) # => [2,3,5,8]

   [1, 2, 3, 4].map(&generate_multiple_proc(3)) # => [3,6,9,12]

Answer 4

这取决于风格。 Lambda 是声明式风格，方法是命令式风格。考虑一下：

Lambda、块、过程都是不同类型的闭包。现在的问题是，何时以及为何使用匿名闭包。我可以回答这个问题——至少在红宝石中！

闭包包含调用它们的位置的词汇上下文。如果从方法内部调用方法，则无法获得调用该方法的上下文。这是由于对象链在 AST 中的存储方式造成的。

另一方面，闭包 (lambda) 可以通过方法与词法上下文一起传递，从而允许延迟求值。

lambda 自然也适合递归和枚举。

Answer 5

在 OOP 的情况下，只有根据您的领域建模，类中应该有这样的操作，您才应该在类中创建函数。

如果您需要一个可以内联编写的快速函数，例如用于比较等，请使用 lambda

另请检查这些 SO 帖子 -

何时使用 lambda，何时使用 Proc.new？

C# Lambda 表达式：我为什么应该使用它们？

何时在 Ruby on Rails 中使用 lambda？

Answer 6

它们被用作“高阶”函数。基本上，对于将一个函数传递给另一个函数的情况，以便接收函数可以根据自己的逻辑调用传入的函数。

这在 Ruby 迭代中很常见，例如 some_list.each { |item| ... } 对 some_list 的每个 item 执行某些操作。尽管请注意，这里我们没有使用关键字 lambda ；如前所述，块基本上是相同的东西。

在 Python 中（因为我们在这个问题上有一个与语言无关的标签），您无法编写类似于 Ruby 块的任何内容，因此 lambda 关键字出现得更频繁。但是，您可以从列表推导式和生成器表达式中获得类似的“快捷方式”效果。

Answer 7

我发现这有助于理解差异：

http ://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/

但总的来说，重点是有时你编写了一个方法，但你不知道你要做什么您将想要在该方法的某个时刻执行操作，因此您可以让调用者决定。

例如：

def iterate_over_two_arrays(arr1, arr2, the_proc)
  arr1.each do |x|
    arr2.each do |y|
      # ok I'm iterating over two arrays, but I could do lots of useful things now
      #  so I'll leave it up to the caller to decide by passing in a proc
      the_proc.call(x,y)
    end
  end
end

然后，您只需调用即可，而不是编写 iterate_over_two_arrays_and_print_sum 方法和 iterate_over_two_arrays_and_print_product 方法：

iterate_over_two_arrays([1,2,3], [4,5,6], Proc.new {|x,y| puts x + y }

或者

iterate_over_two_arrays([1,2,3], [4,5,6], Proc.new {|x,y| puts x * y }

说它更灵活。