Clolog：嵌入式 Clojure 的全功能逻辑编程

Clolog

Source | HN Comments

Clolog 是一个嵌入在 Clojure 中的全功能逻辑编程系统，它支持 Clojure 调用和被 Clojure 调用。它借鉴了 LogLisp 和 Prolog 的思想，并具有 Clojure 的语法优势。Clolog 提供了多种特性，包括基于 Clojure 的语法、逻辑变量、Clojure 调用谓词、失败否定、内置匹配和检查谓词、嵌套逻辑运算符、Cut 运算符、用户自定义谓词转换、完全 leashing、符号作为逻辑术语等。它支持各种类型的术语和谓词，例如字符串、数字、复杂术语、变长谓词等，并提供匿名变量和禁止重复答案的功能。文章还介绍了 Clolog 的语法和搜索过程。

导航菜单

切换导航 Sign in

产品
解决方案按公司规模
- 企业
- 中小型团队
- 初创公司
- 非营利组织按使用场景
- DevSecOps
- DevOps
- CI/CD
- 查看所有使用场景按行业
- 医疗保健
- 金融服务
- 制造业
- 政府
- 查看所有行业查看所有解决方案
资源主题
- AI
- DevOps
- 安全
- 软件开发
- 查看所有探索
- 学习路径
- 活动和网络研讨会
- 电子书和白皮书
- 客户案例
- 合作伙伴
- 高管见解
开源
企业
定价

搜索或跳转到...

搜索代码、仓库、用户、议题、pull requests...

搜索清除搜索语法提示

提供反馈

我们会阅读每一条反馈，并认真对待您的意见。包括我的电子邮件地址，以便我可以联系取消提交反馈

保存的搜索

使用保存的搜索可以更快地过滤您的结果

名称查询要查看所有可用的限定符，请参阅我们的文档。取消创建保存的搜索 Sign in Sign up 重置焦点您在另一个选项卡或窗口中登录。重新加载以刷新您的会话。您在另一个选项卡或窗口中注销。重新加载以刷新您的会话。您在另一个选项卡或窗口中切换了帐户。重新加载以刷新您的会话。关闭警报 {{ message }} bobschrag / **clolog ** 公开

通知您必须登录才能更改通知设置
Fork 2
Star 125

全功能逻辑编程（又名 “Prolog”），嵌入在 Clojure 中/可从 Clojure 调用，并支持对 Clojure 的调用。在 LogLisp、Lisp Machine Prolog 和 Franz Inc. 的 Allegro Prolog 的精神下，有一些额外的优点。

许可证

EPL-2.0 license 125 stars 2 forks Branches Tags Activity Star 通知您必须登录才能更改通知设置

其他导航选项

bobschrag/clolog

main Branches Tags 转到文件代码

文件夹和文件

名称| 名称| 最后提交的消息| 最后提交日期 ---|---|---|---

历史

仓库文件导航

clolog

全功能逻辑编程（又名 “Prolog”），嵌入在 Clojure 中/可从 Clojure 调用，并支持对 Clojure 的调用。在 LogLisp、Lisp Machine Prolog 和 Franz Inc. 的 Allegro Prolog 的精神下，有一些额外的优点。强调表达能力和执行透明性，支持快速原型设计、概念验证开发和外循环推理（即，到目前为止不是很快）。

亮点，带示例

基于 Clojure 的、Lispy（即，同像性）语法，例如...

(do
  ;; 设置，清除知识库。
  (initialize-prolog)
  ;; 创建单元断言。
  (<- (has-subtype vertebrate mammal))
  ;; 执行查询。
  (? ?x ; 答案模板
    (has-subtype vertebrate ?x) ; 目标。
    )
  )
 [mammal] ; 向量中的答案（可能为空）。

逻辑变量-（“?var”）-包含 Clojure seqs（因此，列表）和向量作为“复杂”术语---在断言语句和答案模板中

> (? (?a ?b)
   (same [?a 2] [1 ?b]))
[(1 2)]

Clojure 调用谓词
- 真值检查：truthy?

> (? true (truthy? (+ 1 2)))
[true]

* ?var-bearing 术语统一：`evals-from?`

> (? ?x (evals-from? ?x (+ 1 2)))
[3]

* 副作用：`do`

> (? nil (do (println "Hello")))
Hello
[nil]

访问 Clojure 调用中的 ?var 绑定---即使在带引号的表达式中

> (do (<-- (male laban))
   (? ?y (male ?x) (evals-from? ?y (list '?x))))
[(laban)]

失败否定：not

> (do (initialize-prolog) ; 清除知识库。
   (? :nothing (not (Huh?))))
[:nothing]

通过 evals-from? 简写 ->?，促进在具有 Clojure 调用谓词的目标中访问 Clojure 值

> (binding [*leash* true]
  (? true (same (->? (+ 0 1)) 1)))
0. Processing query: ((same (->? (+ 0 1)) 1))
 Applied ->? transform
 (evals-from?): Entering (evals-from? ??-0:0 (+ 0 1))
 (evals-from?): Succeeded (evals-from? 1 (+ 0 1))
 (same): Entering (same 1 1)
 (same): Succeeded (same 1 1)
Recorded answer: true
Answer limit reached. ; Because answer template `true` has no ?vars.
[true]

内置术语 [非] 匹配谓词：same , different

> (? (?a ?b)
   (same [?a 2] [1 ?b]))
[(1 2)]
> (? (?a ?b)
   (different [?a 2] [1 ?b]))
[]

内置术语检查谓词：var , ground

> (? ?y (var ?x))
[?y]

> (? ?x (same ?x 1) (ground ?x))
[1]

内置无条件谓词：true , false

> (? true (true))
[true]

(? true (false))
[]

可嵌套的内置逻辑运算符：and , or, not, if

> (? ?x (and (if (false)
        (same ?x :succeed)
        (same ?x :fail))
       (evals-from? ?x :fail)
     (or (true) (false))))
[:fail]

“Cut” 运算符：first

> (do (initialize-prolog)
   (<- (sister laban rebecca))
   (<- (sister rachel leah))
   (? [?sibling ?sister]
     (first (sister ?sibling ?sister))))
 [[laban rebecca]]

用户自定义谓词转换，支持（例如）各种 if , cond, optional

> (create-predicate-transform '((if% ?if ?then ?else)
               (if (first ?if) ?then ?else)))

谓词的完全leashing，包括运算符

> (binding [*leash* true]
  (? [?sibling ?sister ?x] 
   (if% (sister ?sibling ?sister)
      (evals-from? ?x true)
      (evals-from? ?x false))))
0. Processing query: ((if% (sister ?sibling ?sister) (evals-from? ?x true) (evals-from? ?x false)))
 (if%): Applying logic transform (if% ?if ?then ?else)
 (if): Entering (if (first (sister ?sibling:0 ?sister:0)) (evals-from? ?x:0 true) (evals-from? ?x:0 false))
 (if): Checking 'if' condition (if (first (sister ?sibling:0 ?sister:0)) (evals-from? ?x:0 true) (evals-from? ?x:0 false))
 (if first): Entering first (first (sister ?sibling:0 ?sister:0))
  1. Entering "sister/2": (sister ?sibling:0 ?sister:0)
  1. Matched head (sister laban rebecca): (sister laban rebecca)
  1. Succeeded "sister/2": (sister laban rebecca)
 (if first): Succeeded, cutting (first (sister laban rebecca))
 (if): Taking 'then' branch of (if (first (sister laban rebecca)) (evals-from? ?x:0 true) (evals-from? ?x:0 false))
 (if evals-from?): Entering (evals-from? ?x:0 true)
 (if evals-from?): Succeeded (evals-from? true true)
 (if): Succeeded (if (first (sister laban rebecca)) (evals-from? true true) (evals-from? true false))
Recorded answer: [laban rebecca true]
 (if first): Failed (first (sister ?sibling:0 ?sister:0))
 (if): Failed (if (first (sister ?sibling:0 ?sister:0)) (evals-from? ?x:0 true) (evals-from? ?x:0 false))
0. Exhausted query: ((if% (sister ?sibling ?sister) (evals-from? ?x true) (evals-from? ?x false)))
[[laban rebecca true]]

符号被解释为逻辑术语或谓词，无论它们在 Clojure 中的值如何

> (do (<- (false true))
   (? ?x (false ?x)))
[true]
> (do (<- (neg? 3))
   (? true (neg? 3)))
[true]

任意 Clojure 对象作为术语或谓词，例如...
- 字符串（支持，例如，RDF URI）

> (do (<- ("false" true))
   (? ?x ("false" ?x)))
[true]

* 数字

> (do (<- (3 neg?))
   (? ?x (3 ?x)))
[neg?]

* 复杂术语

> (do (initialize-prolog)
   (<- ([treasure] (buried ?x)))
 (? ?r ([treasure] ?r)))
[(buried ?unbound-0)]

谓词是 ?var-bearing 复杂术语

> (do (initialize-prolog)
   (<- ([treasure chest] (buried ?x)))
 (? [?r ?thing] ([treasure ?thing] ?r)))
[[(buried ?unbound-0) chest]]

谓词是 ?vars

> (do (initialize-prolog)
   (<- (male jacob))
 (? ?pred (?pred jacob)))
[male]

变长（可变尾/arity）谓词和复杂术语

> (do (initialize-prolog)
   (<- (variadic))
   (<- (variadic 1))
   (<- (variadic 1 2))
   (? ?rest (variadic & ?rest)))
[() (1) (1 2)]
> (do (initialize-prolog)
   (<- (variadic-term [1]))
   (<- (variadic-term [1 2]))
 (? ?rest (variadic-term [1 & ?rest])))
[[] [2]]

目标是 ?vars

> (do (initialize-prolog)
   (<- (male jacob))
 (? ?goal ?goal)) ; 告诉我你能证明的一切。
[(male jacob)]

> (do (initialize-prolog)
   (<- (male jacob))
 (? ?goal (unasserted) ?goal)) ; ...根据你目前所知。
[]

匿名 ?vars

> (do (initialize-prolog)
   (<- (sister laban rebecca))
   (<- (sister rachel leah))
   (? true (sister ?_person ?_person)))
[true]
> (? true (sister ? ?))
[true]

禁止作为（在 ?var 重命名下）重复项的答案

> (do (initialize-prolog)
   (<- (male laban))
 (<- (male jacob))
 (binding [*leash* true]
    (? ?x (or (male ?x) (male ?x)))))
0. Processing query: ((or (male ?x) (male ?x)))
 (or): Entering (or (male ?x:0) (male ?x:0))
 1. Entering "male/1": (male laban)
 1. Matched head (male laban): (male laban)
 1. Succeeded "male/1": (male laban)
Recorded answer: laban
 1. Backtracking into "male/1": (male ?x:0)
 1. Succeeded "male/1": (male jacob)
Recorded answer: jacob
 1. Backtracking into "male/1": (male ?x:0)
 1. Failed "male/1": (male ?x:0)
 (or): Backtracking into (or (male ?x:0) (male ?x:0))
 1. Entering "male/1": (male laban)
 1. Matched head (male laban): (male laban)
 1. Succeeded "male/1": (male laban)
Duplicate answer (not recorded): laban
 1. Backtracking into "male/1": (male ?x:0)
 1. Succeeded "male/1": (male jacob)
Duplicate answer (not recorded): jacob
 1. Backtracking into "male/1": (male ?x:0)
 1. Failed "male/1": (male ?x:0)
 (or): Failed (or (male ?x:0) (male ?x:0))
0. Exhausted query: ((or (male ?x) (male ?x)))
[laban jacob]

可选地禁止被其他答案包含的答案

> (do (initialize-prolog)
   (<- (sister laban rebecca))
   (<- (sister ?x ?y))
   (binding [*leash* true]
    (? [?x ?y] (sister ?x ?y))))
0. Processing query: ((sister ?x ?y))
 1. Entering "sister/2": (sister laban rebecca)
 1. Matched head (sister laban rebecca): (sister laban rebecca)
 1. Succeeded "sister/2": (sister laban rebecca)
Recorded answer: [laban rebecca]
 1. Backtracking into "sister/2": (sister ?x:0 ?y:0)
 1. Succeeded "sister/2": (sister ?x:0 ?y:0)
Recorded subsuming answer (discarded 1 subsumed answer(s)): [?x ?y]
 1. Backtracking into "sister/2": (sister ?x:0 ?y:0)
 1. Failed "sister/2": (sister ?x:0 ?y:0)
0. Exhausted query: ((sister ?x ?y))
[[?x ?y]]

当没有为调用的逻辑谓词和 arity 定义任何断言时，失败（即，不是系统错误）

> (do (initialize-prolog)
        (binding [*leash* true]
         (? answer (undefined ?arity-1))))
0. Processing query: ((undefined ?arity-1))
 1. Entering "undefined/1": (undefined ?arity-1:0)
 1. Failed "undefined/1": (undefined ?arity-1:0)
0. Exhausted query: ((undefined ?arity-1))
[]

语法

在下面的产生式规则中，...

尖括号将语法括起来。
+ 表示一个或多个。
* 表示零个或多个。
":-" 分隔规则的左侧和右侧。
"|" 分隔右侧的替代方案。

: (+ ) :- :- :- | :- (+ ) :- :- (+ * & <?var>) :- | :- | :- | | same | different | var | ground | true | false :- and | or | if | not | first :- truthy? | evals-from? | do : 使用 create-predicate-transform 注册的谓词常量 : 一个谓词，其所有断言（如果有）都来自对 <-... 宏或 assert<-... 函数之一的调用 :- | :- <?var> | :- | :- () | [] :- (* & <?var>) | [* & <?var>] :- 任何支持 Clojure = 的 Clojure 值（因此，不是正则表达式），而不是透明术语