以这个程序为例。它使用延迟目标

room(green).
room(blue).
room(red).
room(white).

location(jimmy,red).
location(ricky,blue).
location(cindy,green).

% "Is a certain room unoccupied?"
   
not_occupied(Room) :-
   nonvar(Room),
   assertion(room(Room)),
   \+ location(_Person,Room).

% If no specific "Room" has been given, the negated goal is
% delayed until the "Room" has been instantiated.

not_occupied(Room) :-
   var(Room),
   !,
   when(
      ground(Room),
      (\+ location(_Person,Room))
   ).

如果我现在问

?- not_occupied(R).

然后 Prolog 成功并输出一个残差目标

?- not_occupied(R).
when(ground(R),\+location(_7676,R)).

实际上，它并没有真正成功。它乐观地成功（因为为了不停止计算，它必须成功）但实际的逻辑成功取决于剩余目标的实际成功。

如何以编程方式找出子目标是否成功实现剩余目标？（然后我该怎么办？） 方法是什么？

聚苯乙烯

具有辅助 Prolog 真值可能是一个不错的 Prolog 扩展，因为 atrue+表示“在剩余目标成功的情况下成功”。这实际上似乎有一定的必要性：

在 SWI-Prolog 中，采用这个固有的模糊目标：

do :- not_occupied(_). …

我们在一个单独的服务器上有一个中央Git存储库.所有团队成员都将其克隆到本地计算机,然后拉/推到该中央存储库.

不幸的是,具有中央仓库的机器已经崩溃并且无法恢复.

现在,我们如何使用开发人员机器中的克隆副本再次重建中央存储库,以及如何将来自不同克隆存储库的本地更改同步到此重建的中央存储库？

谢谢你的帮助.

该leiningen主页显示了一个古板的绅士显然名为"Leiningen".对我来说,"莱宁根"唤起了德国的一个城市.那么莱宁根先生是谁？

在Java 8中,类java.util.Optional(javadoc)类提供"Maybe"Monad或Option Type的功能.

更直接:

public final class java.util.Optional <T> extends Object

容器对象,可能包含也可能不包含非null值.如果存在值,则isPresent()将返回true,get()将返回该值.

其中一种方法是:

<U>可选<U>地图(功能<？super T,？extends U> mapper)

如果存在值,则将提供的映射函数应用于该值,如果结果为非null,则返回描述结果的Optional.

问题是为什么map()在类型上使用类型通配符U.

我对类型通配符的理解很简单:

? super T从指定从该组由子类路径给定类型的一些Object到T(两者Object并T包括)联合在拉出任何subinterfacing路径上找到的组接口"作为sidedish"通过implements.

并? extends U简单地从扩展U(U包括)的类集合中指定一些类型.

所以可以写一下:

<U>可选<U>地图(功能<？super T,U> mapper)

没有丢失信息.

或不？

Clojure的Associative Destructuring允许人们通过数字索引来解构vector（也许是seq或list）。

这种模式是不是在clojure.org提到，到目前为止，但被中提到的Clojure的喜悦，第2版。迈克尔·福格斯（Michael Fogus），克里斯·豪斯（Chris Houser），2014年5月，第14页。59.这种方法出现在“关联解构”一节中-错误地是因为这种基于索引的解构只是“关联解构”的特例，在上述书中被称为“带地图的解构”。

无论如何，结果是意外的（Clojure 1.10.0）：

在所有情况下，都提取索引0和3处的值。

这些工作按预期方式进行：

(let [{firstthing 0, lastthing 3} [1 2 3 4]] [firstthing lastthing])
;=> [1 4]

(let [{firstthing 0, lastthing 3} (vec '(1 2 3 4))] [firstthing lastthing])
;=> [1 4]

但在清单上：

(let [{firstthing 0, lastthing 3} '(1 2 3 4)] [firstthing lastthing])
;=> [nil 4]

为什么nil在位置0？

类似地：

(let [{firstthing 0, lastthing 3} (seq '(1 2 3 4))] [firstthing …

我正在仔细研究约束处理规则(CHR)，看看我是否能理解它们（从某种意义上说，这里计算的是什么以及经典逻辑甚至线性逻辑如何适合于此）并可能应用它们。

Thom Frühwirth 2009 年的书讨论了 CHR 的原则，但实施当然可能有所不同。

在这种情况下，我使用CHR的SWI Prolog 实现。

如果我理解得很好：

1. CHR 的实现将提供至少一个“约束存储”来表达“计算状态”。约束存储仅包含基础原子（即正文字）。
2. 在典型的 CHR 会话中，首先使用初始状态设置约束存储。一种编写包含 CHR 规则的 CHR 程序。然后以约束存储作为参数运行 CHR 程序。重复应用前向链 CHR 规则直到不再适用任何规则，这将迭代地（并且破坏性地）将约束存储从其初始状态转换为某个最终状态。然后可以检查约束存储以找到所需的答案。
3. 在这种情况下，只考虑不关心非确定性（“承诺选择非确定性”）：当多个规则适用于任何中间状态时，采用任何规则。
4. “不知道”不确定性与回溯到后来失败的情况下，选择点是不考虑-这是留给实施，以一种方式或其他提供这一点，如果需要的话。

作为练习，使用欧几里德算法计算 GCD 并保留操作日志的最简单程序：

% Constraint `logg(Ti,Msg)` retains the log message `Msg` at step `Ti`
% (which increases monotonically)
% Constraint `gcdpool(X)` denotes a "GCD pool member". At each step, we want
% to compute the GCD of all the X for which …

我正在尝试使用 Bryan Henderson 对 ncurses 库的 Perl 接口：Curses

对于一个简单的练习，我尝试获取在屏幕上输入的单个字符。这直接基于NCURSES Programming HOWTO并进行了修改。

当我调用 Perl 库的 时getchar()，我希望收到一个字符，可能是多字节的（正如库手册页的这一部分所解释的那样，它有点复杂，因为必须处理功能键和没有输入的特殊情况，但这只是通常的卷发）。

它是read1ch()下面代码中的子程序。

这适用于 ASCII 字符，但不适用于 0x7F 以上的字符。例如，当点击è(Unicode 0x00E8, UTF-8 : 0xC3, 0xA8) 时，我实际上获得了代码 0xE8 而不是 UTF-8 编码的东西。将其打印到LANG=en_GB.UTF-8无法正常工作的终端，无论如何我期待 0xC3A8。

我需要更改什么才能使其工作，即获取è正确的字符或 Perl 字符串？

剪断C代码getchar()是在这里顺便说一句。也许它只是没有用C_GET_WCHset编译？如何发现？

附加物

附录 1

与设置尝试binmode使用

binmode STDERR, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';

这应该解决任何编码问题，因为终端期望并发送 UTF-8，但这没有帮助。

还尝试使用 open设置流编码（不太确定此方法与上述方法之间的区别），但这也无济于事

use open qw(:std :encoding(UTF-8));

附录 …

这件事激起了我对理论的兴趣：

是否可以编写一个不一致的 Prolog 程序，即根据查询方式，只使用纯 Prolog、cut 和来回答false和true的程序false？

例如，一个人可以查询p(1)，Prolog 处理器会说false。但是当有人查询p(X)Prolog 处理器时，它会给出一组答案1，2，3。

这可以通过“计算状态检查谓词”轻松实现，例如var/1（更好地称为fresh/1）+ el cut：

p(X) :- nonvar(X),!,member(X,[2,3]).
p(X) :- member(X,[1,2,3]).

然后

?- p(1).
false.

?- p(X).
X = 1 ;
X = 2 ;
X = 3.

如果这是高保证软件，就会出现“哎哟时间”。自然地，任何命令式程序在其他任何一行上都不会像这样脱轨。

所以。可以没有那些“计算状态检查谓词”吗？

聚苯乙烯

上面说明了 Prolog 的所有谓词实际上都携带了一个“计算状态”的线程隐藏参数：

p(X,StateIn,StateOut).

这可以用来解释var/1和朋友的行为。当 Prolog 程序只调用既不咨询也不修改那个的谓词时，它就是“纯”的State。好吧，至少这似乎是查看正在发生的事情的好方法。我认为。

我一直在尝试将我创建的一段 Prolog 代码转换为 DCG 来表示一个基本的有限自动机。基本上它确保一个可接受的输入是一个 0 和 1 字符串中倒数第三个元素是 1 的输入。

例如[1,0,0,1,0,1]是可以接受的，而[1,0,1,0,0,0]不是。

accept(L) :- steps(q0,L,F), final(F).

steps(Q,[],Q).

steps(Q,[H|T],Q2) :- tran(Q,H,Qn), steps(Qn,T,Q2).

final(q1).

tran(Y,0,n0) :- Y = q0; Y = q1; Y = n0.

tran(Y,1,n1) :- Y = q0; Y = q1; Y = n0. 

tran(n1,X,h1):- X = 0 ; X = 1.

tran(h1,X,q1):- X = 0 ; X = 1.

我的问题本质上是步骤谓词的第二个子句，其中“tran（Q，H，Qn）”的输出用作步骤（Qn，T，Q2）的输入，在这种情况下是变量Qn。

我想出的 DCG 如下：

accept(L) --> final(F),{F = steps(q,L)}.

steps(Q,[]) --> [Q].


steps(Q,[H|T]) --> steps(E,T), {E …

我对数理逻辑很陌生，最近正在尝试学习 Prolog，我想知道是否可以使用 Prolog 进行解析推理，例如，进行以下推理：

1. 知道 ?x.(sheep(x)?eatgrass(x))
2. 知道 ?x.(deadsheep(x)?¬eatgrass(x))
3. 证明 ?x.(deadsheep(x)?¬sheep(x))

我试图意识到的是编写如下代码：

eatgrass(X) :- sheep(X).
false       :- deadsheep(X), eatgrass(X).
sheep(X).
deadsheep(X).

并在查询时获得查询答案“假”

?- sheep(a),deadsheep(a).

似乎在 Prolog 中我无法意识到类似第 2 行的内容：

false :- deadsheep(X), eatgrass(X).

所以我想知道是否有办法像 Prolog 中提到的那样进行推理，谢谢！

以下程序

#!/bin/bash

x=
y="${x:-''}"
z=${x:-''}
k="${x:-}"
l=${x:-}

echo "x = [$x]"
echo "y = [$y]"
echo "z = [$z]"
echo "k = [$k]"
echo "l = [$l]"

(shellcheck说'没有发现问题')

产量

x = []
y = ['']
z = []
k = []
l = []

表示的参数扩展${parameter:-word}在bash的手册页中描述如下:

$ {parameter:-word}:使用默认值.如果参数未设置或为null,则替换单词的扩展.否则,参数的值将被替换.

如何评估"${x:-''}"字符串''中的结果而不是空字符串？

我有一个Perl代码,带有HERE文档.在HERE文档的文本中,嵌入了关键字case.这似乎使Switch声明大为令人不安.我疯了吗？

#!/usr/bin/perl

use strict;
use warnings;
use utf8;  # Meaning "This lexical scope (i.e. file) contains utf8"

use Switch;

sub printUsage {
   print STDERR << "HERE";

                       +
  --rollback           | - In case of "--reallydo", perform a ROLLBACK instead of a COMMIT at
                       |   transaction end.
                       + 
HERE
}

在Perl 5.16中运行它给出:

Bad case statement (invalid case value?) near avo2.pl line 13

即In case of字面意思是"不在这里".一些bug？我应该在Perl bug跟踪器中提出这个问题吗？

这是递归的一个简单序言示例。我不知道在哪里，或多或少地如何声明退出语句。试飞(sofia, dublin) 应该返回true，但它会在最后一步不断检查你是否可以directFlight(dublin, dublin)。这是代码：

directFlight(sofia, varna).
directFlight(sofia, paris).
directFlight(sofia, london).
directFlight(london, edinburg).
directFlight(paris, new_york).
directFlight(new_york, seattle).
directFlight(london, dublin).

flight(City1, City2) :- 
   directFlight(City1, City3),      
   flight(City3, City2).

输出：

 [trace]  ?- flight(sofia, dublin).
   Call: (8) flight(sofia, dublin) ? creep
   Call: (9) directFlight(sofia, _878) ? creep
   Exit: (9) directFlight(sofia, varna) ? creep
   Call: (9) flight(varna, dublin) ? creep
   Call: (10) directFlight(varna, _878) ? creep
   Fail: (10) directFlight(varna, _878) ? creep
   Fail: (9) flight(varna, dublin) ? creep
   Redo: (9) directFlight(sofia, _878) ? creep
   Exit: (9) …