PROSAGA码农传奇-lisp-在lisp中的第一次搜索下进行前向链接

<div class =“post-text”itemprop =“text”>
  <P>
    以下是有关代码中某些错误的一般性说明，后面是有关如何实现正向链接的提示。
  </p>
  <H2>
    代码格式
  </H2>
  <P>
    正确格式化代码非常重要，否则您或您的同行将无法轻松阅读。例如，参见
    <a href="https://lisp-lang.org/style-guide/" rel="nofollow noreferrer">
      https://lisp-lang.org/style-guide/
    </A>
    ：
  </p>
   <pre>
    <code>
      (defun conclusion-part( r)
(caddr r)
)

</code>
  </pre>
  <P>
    上面有各自的括号，这不是惯用语。另外，Common Lisp有一个名为的函数
     <code>
      THIRD
    </code>
     这比比较容易理解
     <code>
      CADDR
    </code>
     对大多数人来说。正确缩进并将括号放在最后。使用像Emacs这样的编辑器可以自动缩进代码：这有助于识别您编写的内容与您要编写的内容不同的情况，因为自动缩进遵循列表结构并可以帮助发现错位的括号。
  </p>
   <pre>
    <code>
      (defun conclusion-part (rule)
  (third rule))

</code>
  </pre>
  <H2>
    访问器功能
  </H2>
  <P>
    你做得好的是定义一个
     <code>
      conclusion-part
    </code>
     访问器功能访问您的部分
    <EM>
      规则
    </EM>
     临时数据结构。拥有一组与特定实现无关的独特访问器会有所帮助，并且是引入有意义名称的好机会。您应该对规则的所有部分执行相同操作（您在其他地方直接使用CADR，这不是很干净）。
  </p>
  <P>
    例如（随意找到更好的名字）：
  </p>
   <pre>
    <code>
      (defun rule-name (rule) (first rule))
(defun rule-antecedent (rule) (second rule))
(defun rule-consequent (rule) (cddr rule))

</code>
  </pre>
  <P>
    请注意
     <code>
      rule-consequent
    </code>
     是我改写的
     <code>
      conclusion-part
    </code>
    ，除了它总是返回一个包含单个元素的列表（你能明白为什么吗？）。这在你打电话后很有用
     <code>
      append
    </code>
    ，这是一致的
     <code>
      rule-antecedent
    </code>
     返回一个列表。
  </p>
  <H2>
    规则的可操作性
  </H2>
  <P>
    返回true或false的函数称为谓词，并按约定为后缀
     <code>
      -p
    </code>
     在Lisp（和
     <code>
      -?
    </code>
     在Scheme）。您可能会也可能不会遵循该规则，但请引入更有意义的变量名称。以下是如何重写它：
  </p>
   <pre>
    <code>
      (defun actionablep (rule facts)
  (dolist (term (rule-antecedent rule) t)
    (unless (member term facts)
      (return nil))))

</code>
  </pre>
  <P>
    既然你已经知道了
     <code>
      loop
    </code>
    ，你也可以写：
  </p>
   <pre>
    <code>
      (defun actionablep (rule facts)
  (loop
    :for term :in (rule-antecedent rule)
    :always (member term facts)))

</code>
  </pre>
  <H2>
    正向链接
  </H2>
  <P>
    这里也存在一些问题：
  </p>
  <UL>
    <LI>
      <P>
        你不要使用返回值
        <a href="http://clhs.lisp.se/Body/f_rm_rm.htm" rel="nofollow noreferrer">
           <code>
            REMOVE
          </code>
        </A>
         要么
        <a href="http://clhs.lisp.se/Body/f_append.htm" rel="nofollow noreferrer">
           <code>
            APPEND
          </code>
        </A>
        ，这些函数可以保证不会改变它们的参数（不像
         <code>
          DELETE
        </code>
         和
         <code>
          NCONC
        </code>
        ，即使对于那些函数，只有返回的值很重要，授予改变现有存储的能力是实现定义的，只有那里才能有效地重用内存。
      </p>
    </LI>
    <LI>
      <P>
        在某些分支中，您想要返回
         <code>
          "yes"
        </code>
        ， 在另一个
         <code>
          nil
        </code>
        ; CL可能是动态类型的，但这里不需要字符串返回值。
      </p>
    </LI>
    <LI>
      <P>
        一个
         <code>
          return
        </code>
         形式只存在于最里面
         <code>
          nil
        </code>
         块。在你的情况下，这意味着你从建立的隐式块返回
        <a href="http://clhs.lisp.se/Body/m_dolist.htm" rel="nofollow noreferrer">
           <code>
            DOLIST
          </code>
        </A>
        而不是那个
        <a href="http://www.lispworks.com/documentation/lw60/CLHS/Body/m_loop.htm" rel="nofollow noreferrer">
           <code>
            LOOP
          </code>
        </A>
        。你可以说出你的名字
         <code>
          loop
        </code>
         但实际上这里没有必要，你可以不用写整篇文章
         <code>
          return
        </code>
        。更一般地说，您可以使用纯粹的功能方法。
      </p>
    </LI>
  </UL>
  <H2>
    暗示
  </H2>
  <P>
    我写了一篇
     <code>
      forward-chaining
    </code>
     功能，并追溯它;在REPL中：
  </p>
   <pre>
    <code>
      CL-USER> (trace forward-chaining)

</code>
  </pre>
  <P>
    以下是我测试实现的方法：
  </p>
   <pre>
    <code>
      (forward-chaining '(B C)
                  '((R1 (B D E) F)
                    (R2 (D G) A)
                    (R3 (C F) A)
                    (R4 (C) D)
                    (R5 (D) E)
                    (R6 (A) H)
                    (R7 (B) X)
                    (R8 (X C) A))
                  'H)

</code>
  </pre>
  <P>
    我正在使用SBCL测试代码，实际输出可能在您的Lisp实现中有所不同：
  </p>
   <pre>
    <code>
        0: (FORWARD-CHAINING (B C) ((R1 (B D E) F) (R2 (D G) A) (R3 (C F) A) (R4 (C) D) (R5 (D) E) (R6 (A) H) (R7 (B) X) (R8 (X C) A)) H)
    1: (FORWARD-CHAINING (B C D) ((R1 (B D E) F) (R2 (D G) A) (R3 (C F) A) (R5 (D) E) (R6 (A) H) (R7 (B) X) (R8 (X C) A)) H)
      2: (FORWARD-CHAINING (B C D E) ((R1 (B D E) F) (R2 (D G) A) (R3 (C F) A) (R6 (A) H) (R7 (B) X) (R8 (X C) A)) H)
        3: (FORWARD-CHAINING (B C D E F) ((R2 (D G) A) (R3 (C F) A) (R6 (A) H) (R7 (B) X) (R8 (X C) A)) H)
          4: (FORWARD-CHAINING (B C D E F A) ((R2 (D G) A) (R6 (A) H) (R7 (B) X) (R8 (X C) A)) H)
            5: (FORWARD-CHAINING (B C D E F A H) ((R2 (D G) A) (R7 (B) X) (R8 (X C) A)) H)
            5: FORWARD-CHAINING returned (H)
          4: FORWARD-CHAINING returned (H)
        3: FORWARD-CHAINING returned (H)
      2: FORWARD-CHAINING returned (H)
    1: FORWARD-CHAINING returned (H)
  0: FORWARD-CHAINING returned (H)

</code>
  </pre>
  <P>
    该计划的基本结构是：
  </p>
   <pre>
    <code>
      (defun forward-chaining (rules facts goal)
  (or ...
      (loop 
        for ... in ...
        thereis (and (actionablep ... ...)
                     (forward-chaining ... ... ...)))))

</code>
  </pre>
  <P>
    换句话说：要么目标已经是已知的事实，要么存在一个可行的规则，通过该规则可以传递目标。请注意，如果规则是非终止的，则可能会有无限递归。
  </p>
  <P>
    您访问规则的顺序确定您的策略是否为深度优先（始终遵循最后一次尝试的规则并从该规则开始，使用规则列表作为堆栈），或广度优先（使用规则列表应用给定事实的所有可激活规则）作为一个队列）。我不知道“第一次搜索”这个术语来自哪里，我没有发现它的严重参考（有一篇论文引用
    <EM>
      莱森森＆amp; Schardl 2010
    </EM>
     在谈论时
    <EM>
      下面
    </EM>
     先搜索，但是
    <a href="http://www.csd.uwo.ca/~moreno/CS433-CS9624/Resources/Leiserson-Schardl-2010.pdf" rel="nofollow noreferrer">
      参考文章
    </A>
     只是没有提到它
    <EM>
      广度优先
    </EM>
    ，这是众所周知的）。
  </p>
</DIV>