在ruby中实现iota

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

所以！我找到了一个关于深奥编程语言的网站，发现了Iota。Iota可以说是最小的函数语言。您可以在此处阅读更多信息：以下是方案中物联网的参考实施：

(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实现在优雅方面相当的东西时，它最终会抛出一个“糟糕的过程”。谁能帮助我理解Ruby为什么会这样，以及如何更好地实现它。在试图实现这一点的同时，为了便于阅读，我将

S

、

K

和

BASIS

分开

我在底部包括了两个测试。第一个应该返回

I

（

BASIS[BASIS]

），但它返回的proc不会产生与

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)

S=lambda{| f | lambda{| g | lambda{| x | f[x][g[x]}
K=lambda{| x | lambda{| y | x}
基=λ{| c | c[S][K]}
iota=λ{s|
s=s.chars
i=λ{
如果s.next='*'
i[i]
其他的
基础
结束
}
}
p基[BASIS][1]#=>1
p物联网[“*ii”][1]#=>#
pk[1][2]#=>1
p iota[“*i*i*ii”][1][2]#=>第3行：“[]”中：无法将过程转换为整数（TypeError）

在第9行，您正在调用

i[i]

，但是

i

不接受任何参数-只有

i

返回的lambda接受任何参数。因此，您应该调用

i

，不带任何参数，然后调用调用

i

的结果，并将

i

作为其参数，即

i[][i]

，多亏了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

---

谢谢，正是我需要的。不过，它仍然返回了

K

和

I

（在物联网中）的错误值。对于

I

它返回

proc

对象，对于

K

它返回

2

。。。这可能是正确的值，尽管我希望它返回

1

。