Question

我正在尝试在Alloy中构造一个递归函数。根据Daniel Jackson的书中显示的语法，这是可能的。我的职责是：

fun auxiliarToAvoidCiclicRecursion[idTarget:MethodId, m:Method]: Method{
    (m.b.id = idTarget) => {
        m
    } else (m.b.id != idTarget) => {
        (m.b = LiteralValue) => {
           m 
        } else {
           some mRet:Method, c:Class | mRet in c.methods && m.b.id = mRet.id => auxiliarToAvoidCiclicRecursion[idTarget, mRet]
        }       
    }
}

但解决方案声称呼叫auxiliarToAvoidCiclicRecursion[idTarget, mRet]说：

"This must be a formula expression.
Instead, it has the following possible type(s):
{this/Method}"

Answer 1

问题正是错误消息所说的：auxiliarToAvoidCiclicRecursion函数的返回类型是Method，您试图在布尔含义中使用，其中公式是预期的（即，某些内容）布尔类型）。你会在任何其他静态类型的语言中得到同样的错误。

您可以将函数重写为谓词来解决此问题：

pred auxiliarToAvoidCiclicRecursion[idTarget:MethodId, m:Method, ans: Method] {
    (m.b.id = idTarget) => {
        ans = m
    } else (m.b.id != idTarget) => {
        (m.b = LiteralValue) => {
           ans = m 
        } else {
           some mRet:Method, c:Class {
             (mRet in c.methods && m.b.id = mRet.id) => 
                auxiliarToAvoidCiclicRecursion[idTarget, mRet, ans]
           }
        }       
    }
}

这不应该给你一个编译错误，但要运行它，请确保启用递归（Options - ＆gt; Recursion Depth）。正如您将看到的，最大递归深度为3，这意味着无论分析范围如何，Alloy Analyzer都可以将您的递归调用最多展开3次。当这还不够时，您仍然可以选择重写模型，以便将所讨论的递归谓词建模为关系。这是一个简单的例子来说明这一点。

带有递归定义函数的链表，用于计算列表长度：

sig Node {
  next: lone Node
} {
  this !in this.^@next
}

fun len[n: Node]: Int {
  (no n.next) => 1 else plus[1, len[n.next]]
}

// instance found when recursion depth is set to 3
run { some n: Node | len[n] > 3 } for 5 but 4 Int

// can't find an instance because of too few recursion unrollings (3), 
// despite the scope being big enough
run { some n: Node | len[n] > 4 } for 5 but 4 Int

现在将len建模为关系的同一列表（即Node中的字段）

sig Node {
  next: lone Node,
  len: one Int
} {
  this !in this.^@next
  (no this.@next) => this.@len = 1 else this.@len = plus[next.@len, 1]
}

// instance found
run { some n: Node | n.len > 4 } for 5 but 4 Int

请注意，后一种方法不使用递归（因此不依赖于“递归深度”配置选项的值），可能（并且通常是）显着慢于前者。

编程合金中的递归函数

1 个答案: