似乎scala的解析器组合器不会回溯.我有一个语法(见底部),无法正确解析以下"stmt":

copy in to out .

这应该很容易用回溯解析:

stmt: (to out(copy in))

还是我错过了什么？

分析器:

type ExprP = Parser[Expr]
type ValueP = Parser[ValExpr]
type CallP = Parser[Call]
type ArgsP = Parser[Seq[Expr]]

val ident     = "[a-zA-Z\\+\\-\\*/%><\\\\\\=]+".r
val sqstart   = "\\["                          .r
val sqend     = "\\]"                          .r
val del       = ","                            .r
val end       = "\\."                          .r

def stmt: ExprP      = expr <~ end
def expr: ExprP      = ucall | call | value
def value: ValueP    = ident ^^ {str => IdentExpr(str)}
def call: …

为了了解固定点组合器是什么和用于什么,我写了自己的.但不是用严格的匿名函数编写它,比如维基百科的例子,我只使用了define:

(define combine (lambda (functional)
                  (functional (lambda args (apply (combine functional) args))))

我用factorial和fibonacci的函数来测试它,它似乎工作.这是否符合定点组合器的正式定义？

考虑这个组合子:

S (S K)

将其应用于参数XY:

S (S K) X Y

它签订合同:

X Y

我将S(SK)转换为相应的Lambda术语并得到了这个结果:

(\x y -> x y)

我使用Haskell WinGHCi工具获取(\ xy - > xy)的类型签名,并返回:

(t1 -> t) -> t1 -> t

这对我来说很有意义.

接下来,我使用WinGHCi获取s(sk)的类型签名并返回:

((t -> t1) -> t) -> (t -> t1) -> t

这对我来说没有意义.为什么类型签名不同？

注意:我将s,k和i定义为:

s = (\f g x -> f x (g x))
k = (\a x -> a)
i = (\f -> f)

回想一下,K组合器是一个常数函数.它总是返回它的第一个参数:

Kxy = x for all y

在To Mock a Mockingbird这本书中,作者提供了一个含有说话鸟类的魔法森林的例子.这些鸟有行为:

鉴于任何鸟类A和B,如果您将B的名称称为A,那么A将通过向您呼叫某只鸟的名称来回应:这只鸟我们将由AB指定.

假设森林由三只鸟A,B和C组成.至少有一只鸟可能像K组合一样吗？

下面的表格显示了魔法森林中鸟类的一组可能行为.第一列包含森林中每只鸟的名称.顶行的名称可以调用每只鸟.身体是鸟对名字的反应.例如,如果您将A的名称称为鸟A,则鸟A将以C响应(请参阅第2行第2列).简洁地说,AA = C.如果你把B的名字叫做鸟A,那么鸟A会回答B(见第2行,第3栏).简洁地说,AB = B. AC的空槽应该有什么值？

   | A    B    C
------------------
A  | C    B
B  | B    B    B
C  | A    A    A

让我们看看我们是否可以让鸟A表现得像K组合器.上面的一组值看起来很有希望:

• 对于所有y,AA = C且Cy = A. 也就是说,对于所有y,(AA)y = A.

• 对于所有y,AB = B且By = B. 也就是说,对于所有y,(AB)y = B.

空槽(AC)应该放置什么值？考虑所有情况:

• 如果AC = A则所有y的Ay值必须为C,这显然是错误的.因此,A不能是空槽的正确值.

• 如果AC = B则所有y的By值必须为C,这显然是假的.因此,B不能是空槽的正确值.

• 如果AC = C则所有y的Cy值必须为C,这显然是假的.因此,C不能是空槽的正确值.

因此,对于每个y,不能在空槽中放置值以满足条件(AC)y = C.

据我所知,不可能让任何一只鸟表现得像K组合器.我希望你能证明我错了.

假设你有三个arity 1,2和3的函数,如下所示:

(defn I [x] x)
(defn K [x y] x)
(defn S [x y z] (x z (y z)))

clojure是否具有用于评估的评估函数或习语:

(I K S I I) as (I (K (S (I (I)))))

返回arity 2的一个parital功能？

我正在考虑创建一个宏,它可以采用上面的简单函数定义,并将它们扩展为可以返回部分结果的多元函数.如果已经有内置或惯用的方法来实现这一点,我不想创建宏.

以下是扩展宏对上述函数的期望:

(defn I
  ([x] I x)
  ([x & more] (apply (I x) more)))

(defn K
  ([x] (partial K x))
  ([x y] x)
  ([x y & more] (apply (K x y) more)))

(defn S
  ([x] (partial S x))
  ([x y] (partial S x y))
  ([x y …

;; compute the max of a list of integers

(define Y
  (lambda (w)
    ((lambda (f)
       (f f))
     (lambda (f)
       (w (lambda (x)
            ((f f) x)))))))

((Y
  (lambda (max)
    (lambda (l)
      (cond ((null? l) -1)
            ((> (car l) (max (cdr l))) (car l))
            (else (max (cdr l)))))))
 '(1 2 3 4 5))

我想了解这个结构。有人能给这段代码一个清晰简单的解释吗？

例如，假设我忘记了 Y 的公式。我如何记住它，并在使用它很久之后重现它？

我在解释foldl的函数签名时遇到了麻烦.我理解它是如何工作的,但我不确定它与签名的关系.

我对它的细节有几个疑问

foldr :: (a -> b -> b) -> b -> [a] -> b

foldr (+) 5 [1,2,3,4]

看起来第一个参数需要一个加法函数:

(a -> b -> b)

在函数参数中,到底发生了什么？在这种情况下,此部分是否将最右侧的整数a应用于累加器b以产生另一个整数9？在此之后,它是否会返回一个以累加器作为参数的函数？

接下来,下面的最后两个参数是什么意思？

[a] -> b

非常感谢.

在Scala中生成已知数量的列表的组合非常简单.你可以使用for-understanding:

for {
   elem1 <- list1
   elem2 <- list2 } yield List(elem1, elem2)

或者您可以使用脱糖版本:

list1.flatMap( elem1 => list2.map(elem2 => List(elem1,elem2)))

在套件之后,我想创建N个列表中的元素组合(N在运行时已知).在组合器示例之后,3个列表将是:

list1.flatMap( elem1 => list2.flatMap(elem2 => list3.map(elem3 => List(elem1,elem2,elem3)))

所以我看到了模式,我知道那里有一个递归,但我一直在努力将它固定下来.

def combinations[T](lists:List[List[T]]): List[List[T]] = ???

有任何想法吗？

概念

我正在实现一个解释器,允许用户定义任意组合器并将它们应用于任意术语.例如,用户可以通过输入以下组合子定义来定义对的Church编码:

pair a b c ? c a b
true a b ? a
first a ? a true

然后用户可以输入first (pair a b),根据先前定义的规则逐步减少:

first (pair a b)
? pair a b true
? true a b
? a

也可以定义其他组合器,例如SKI组合子演算中使用的组合器:

S x y z ? x z (y z)
K x y ? x
I x ? x

身份组合子也可以在头两个组合子条款所限定I ? S S K K或I ? S K …

implicit class KComb[A](a: A) {
  def K(f: A => Any): A = { f(a); a }
}

鉴于 K 组合器的这种实现，我们可以在应用副作用的同时链接一个值的方法调用，而无需临时变量。例如：

case class Document()
case class Result()

def getDocument: Document = ???
def print(d: Document): Unit = ???
def process(d: Document): Result = ???

val result = process(getDocument.K(print))
// Or, using the thrush combinator
// val result = getDocument |> (_.K(print)) |> process

现在，我需要做一些类似的事情，但改用 IO monad。

def getDocument: IO[Document] = ???
def print(d: Document): IO[Unit] = ???
def process(d: Document): IO[Result] …