Ruby与Lambda演算

我正在尝试用procs和ruby来理解lambda演算。下面是一些代码：

puts -> x { -> y {x.call(y) } }
# => #<Proc:0x2a3beb0@C:/first-ruby.rb:1 (lambda)>

puts -> x { x + 2}.call(1)
# => 3

put->x{->y{x.call（y）}
# => #
puts->x{x+2}.call（1）
# => 3

在上面的例子中，

->

表示什么？是将值传递给调用方的

call

方法，因此在第一个示例中，值

y

传递给

y

，在第二个示例中，

1

传递给

x

？在第二个示例中，为什么将

1

计算为

x

在上面的例子中，

->

表示什么

->

是lambdas的文本语法的一部分，就像说，

“

是字符串的文本语法的一部分

.call

方法只是将值从传递给调用者

call

方法就是调用（或执行）lambda的方法。

调用

方法的参数绑定到lambda的参数

因此，在第一个示例中，值

y

被传递到

y

，在第二个示例中

1

被传递到

x

否，在第一个示例中，

y

被传递到外部lambda并绑定到其

x

参数。在第二个示例中，

1

被传递给lambda并绑定到其

x

参数

在第二个示例中，为什么将

1

计算为

x

1

不计算为

x

1

是一个立即值，在Ruby中，立即值总是自己计算

1

将始终计算为

1

，而不会计算为

x

或任何其他值

在上面的例子中，

->

表示什么

->

是lambdas的文本语法的一部分，就像说，

“

是字符串的文本语法的一部分

.call

方法只是将值从传递给调用者

call

方法就是调用（或执行）lambda的方法。

调用

方法的参数绑定到lambda的参数

因此，在第一个示例中，值

y

被传递到

y

，在第二个示例中

1

被传递到

x

否，在第一个示例中，

y

被传递到外部lambda并绑定到其

x

参数。在第二个示例中，

1

被传递给lambda并绑定到其

x

参数

在第二个示例中，为什么将

1

计算为

x

---

1

不计算为

x

1

是一个立即值，在Ruby中，立即值总是自己计算

1

将始终计算为

1

，而不会计算为

x

或任何其他值。

这是纯lambda表达式的快捷方式：

lmbd = -> arg{ something to do with arg } # With ->{} notation

lmbd = lambda { |arg| something to do with arg } # Standard notation

在第一个示例中，使用Proc（lambda）对象调用put方法，这就是为什么在输出中会看到

在第二个示例中，使用lmbd.call（1）方法调用puts，即puts输出lambda计算的结果

因此，如果您有lmbd变量，它是lambda对象，您可以像传递任何参数一样传递它，然后通过调用

lmbd.call（）

，获得它的结果：

---

这是纯lambda表达式的快捷方式：

lmbd = -> arg{ something to do with arg } # With ->{} notation

lmbd = lambda { |arg| something to do with arg } # Standard notation

在第一个示例中，使用Proc（lambda）对象调用put方法，这就是为什么在输出中会看到

在第二个示例中，使用lmbd.call（1）方法调用puts，即puts输出lambda计算的结果

因此，如果您有lmbd变量，它是lambda对象，您可以像传递任何参数一样传递它，然后通过调用

lmbd.call（）

，获得它的结果：

---

让我们使用Ruby lambda定义一个函数

def plus_two # no args here
  ->(x) {x + 2} # args go here
end

# assign a value
x = 1

# call it
plus_two.call(x)
# => 3

您的第一个示例有点复杂，但是使用这个想法，您应该能够提出函数方法。 我在学习Scala，函数式编程是基于这些替换原则的

尝试使用这些函数执行一些递归。 这就像调用函数中的函数n次。 那么基本情况是什么呢

至于Lambda演算

尽量使事情简单化，并展示步骤，而不是试图弄清楚一行程序在做什么。是的，它们很好，但如果你看不懂，你就无法理解

以下是我最近正在做的事情：

require 'date'

num = DateTime.now.to_time.utc.to_datetime.ajd - 2451545.0
@t = num / 36525.0

# the terms in reverse order form for the array
@l0_a = [1.0/-19880000.0,
         1.0/-152990.0,
         1.0/499310.0,
         0.0003032028,
         36000.76982779,
         280.4664567]

 # make an enumerator
 @l0_e = @l0_a.each

 # make a lambda to pass the enumerator to.
 def my_lambda
   ->(x) {x.reduce {|acc, el| acc * @t + el} % 360}
 end

 puts  my_lambda.call(@l0_e)

---

这是使用枚举器方法的太阳公式的平均经度，当然还有lambda。

让我们使用Ruby lambda定义一个函数

def plus_two # no args here
  ->(x) {x + 2} # args go here
end

# assign a value
x = 1

# call it
plus_two.call(x)
# => 3

您的第一个示例有点复杂，但是使用这个想法，您应该能够提出函数方法。 我在学习Scala，函数式编程是基于这些替换原则的

尝试使用这些函数执行一些递归。 这就像调用函数中的函数n次。 那么基本情况是什么呢

至于Lambda演算

尽量使事情简单化，并展示步骤，而不是试图弄清楚一行程序在做什么。是的，它们很好，但如果你看不懂，你就无法理解

以下是我最近正在做的事情：

require 'date'

num = DateTime.now.to_time.utc.to_datetime.ajd - 2451545.0
@t = num / 36525.0

# the terms in reverse order form for the array
@l0_a = [1.0/-19880000.0,
         1.0/-152990.0,
         1.0/499310.0,
         0.0003032028,
         36000.76982779,
         280.4664567]

 # make an enumerator
 @l0_e = @l0_a.each

 # make a lambda to pass the enumerator to.
 def my_lambda
   ->(x) {x.reduce {|acc, el| acc * @t + el} % 360}
 end

 puts  my_lambda.call(@l0_e)

---

这是使用枚举器方法的太阳平均经度公式，当然还有一个lambda。

您是想理解Ruby还是lambda演算？你的包里真的有很多猫。对于Ruby如何以各种方式处理lambdas，您得到了一些很好的答案。lambda是一个Proc。从Kernel doc“相当于Proc.new，但结果Proc对象除外，检查调用时传递的参数数。”因此Kernel有lambda函数或方法，但您可以通过查看包含lambda的Proc了解更多信息？和是一种检查过程类型的方法，对于常规的过程对象，额外的参数被忽略，但是对于lambdas，可能会产生错误