2

我提前道歉再次提出这个问题。我之前就在这里的 Haskell 实现问过这个问题，但我仍然很难理解它是如何工作的。此外，我发现极简编程语言的概念绝对令人着迷并且无法摆脱它......无论如何，这不是怀念函数式编程之美的地方。

所以！我找到了一个关于深奥编程语言的网站并发现了 Iota。Iota 可以说是最小的函数式语言。您可以在此处阅读更多相关信息：“Iota 和 Jot：最简单的语言？” 这是Iota在Scheme中的参考实现：

(let iota ()
   (if (eq? #\* (read-char)) ((iota)(iota))
       (lambda (c) ((c (lambda (x) (lambda (y) (lambda (z) ((x z)(y z))))))
                    (lambda (x) (lambda (y) x))))))

但是，当我尝试与 Ruby 中的 Scheme 实现相当的优雅时，它最终会吐出一个“坏 proc”。谁能帮我理解为什么 Ruby 会这样，以及如何更好地实现它。在尝试使其正常工作时，我保留S,K和BASIS分开只是为了便于阅读。

我在底部包括了两个测试。第一个应该返回I( BASIS[BASIS])，但它返回的结果与I. 第二个测试应该返回K，但它返回一个错误。

S = lambda {|f| lambda {|g| lambda {|x| f[x][g[x]] }}}
K = lambda {|x| lambda {|y| x }}
BASIS = lambda {|c| c[S][K] }

iota = lambda{|s|
   s = s.chars
   i = lambda {
      if s.next == '*'
         i[i]
      else
         BASIS
      end
   }
}

p BASIS[BASIS][1]         # => 1
p iota["*ii"][1]          # => #<Proc:0x000000010016b290>

p K[1][2]                 # => 1
p iota["*i*i*ii"][1][2]   # => line 3:in `[]': can't convert Proc into Integer (TypeError)
4

2 回答 2

4

在第 9 行，您正在调用i[i]，但i不接受任何参数 - 只有返回的 lambda 才接受i。所以你应该i不带参数调用，然后调用调用的结果i作为i它的参数，即i[][i]。

于 2012-08-31T16:37:08.133 回答
1

感谢 sepp2k，我想我明白了，这是任何有兴趣的人的答案：

S = lambda {|f| lambda {|g| lambda {|x| f[x][g[x]] }}}
K = lambda {|x| lambda {|y| x }}
BASIS = lambda {|c| c[S][K] }

iota = lambda{|s|
   s = s.chars
   i = lambda {
      if s.next == '*'
         i[][i[]]
      else
         BASIS
      end
   }
   i[]
}

p BASIS[BASIS][1]          # => 1
p iota["*ii"][1]           # => 1

p K[1][2]                  # => 1
p iota["*i*i*ii"][1][2]    # => 1
于 2012-08-31T18:15:29.843 回答