Ok, the aspiring academic Prolog idiot might want
to know more. But from PEG context it should be clear,

that this is the declarative reading for parsing, i.e.
mode p(+,-). Not sure whether it is suitable for other

modes. Didn't use it in other modes...

P.S.: Maybe if you look long enough out of a window,
you might see a pink Unicorn fly by, its the same

with bidirectional DCG grammars....

Mostowski Collapse schrieb am Donnerstag, 5. Mai 2022 um 12:56:04 UTC+2:
> The declarative reading is relatively trivial.
> Take this example from above:
>
> p(A, B) :-
> \+ q(A, _),
> A = C,
> r(C, B).
>
> The declarative reading is as follows:
>
> p(A, B) ←
> ¬ ∃D q(A, D) ∧
> A = C ∧
> r(C, B).
>
> Its not really rocket science. But because its negation
> as failure you might also need Clark Completion etc..
> Mostowski Collapse schrieb am Donnerstag, 5. Mai 2022 um 12:19:59 UTC+2:
> > Looks like UWN is confusing GitHub with Facebook, with his up votes.
> > And sometimes UWN thinks its YouTube, with his down votes?
> > Mostowski Collapse schrieb am Donnerstag, 5. Mai 2022 um 12:08:16 UTC+2:
> > > Its also nicely explained:
> > >
> > > The not-predicate expression !e succeeds if e fails and fails if e
> > > succeeds, again consuming no input in either case.
> > > Mostowski Collapse schrieb am Donnerstag, 5. Mai 2022 um 12:04:07 UTC+2:
> > > > When it is 2022, but you are still living in 2013:
> > > > https://stackoverflow.com/questions/12758567/legitimate-uses-of-1
> > > >
> > > > The question has two former answers from me. Stackoverflow didn't
> > > > allow me to delete them. Nobody else has answered, and you are
> > > > asking the wrong question.
> > > >
> > > > I find that ECLiPSe Prolog, SWI-Prolog, GNU Prolog and SICStus
> > > > Prolog support it. They all are able to support (\+)/1 inside DCG.
> > > > You can also add Tau-Prolog to the list and a couple
> > > >
> > > > of more Prolog systems. The (\+)/1 is nowadays part of PEG.
> > > >
> > > > parsing expression grammar (PEG)
> > > > Not-predicate: !e
> > > > https://en.wikipedia.org/wiki/Parsing_expression_grammar
> > > >
> > > > It has million of uses, they are all legitimate.

Look Ma, a FOL resolution theorem prover in Prolog:
See also: http://logic.stanford.edu/intrologic/chapters/chapter_14.html

many([], S, S).
many([C|T], S, R) :- next(C, T, S, R).

next(C, T, S, R) :- member(D, S), weaker(D, C), !, many(T, S, R).
next(C, T, S, R) :- filter(S, C, K), apply(C, K, H),
append(T, H, J), many(J, [C|K], R).

apply(C, S, T) :-
findall(E, (member(D, S), resolvent(C, D, E)), T).

resolvent(C, D, E) :-
select(A, C, H), factor(A, H, C2),
select(B, D, J), factor(B, J, D2),
opposite(A, B),
append(C2, D2, E).

opposite(pos(A), neg(A)).
opposite(neg(A), pos(A)).

factor(_, C, C).
factor(A, C, C2) :- select(A, C, H), factor(A, H, C2).

filter([], _, []).
filter([D|L], C, R) :- weaker(C, D), !, filter(L, C, R).
filter([D|L], C, [D|R]) :- filter(L, C, R).

weaker(C, D) :- \+ \+ (numbervars(D, 0, _), subset(C, D)).

subset([], _).
subset([X|L], R) :- member(X, R), subset(L, R).

% ?- many([[pos(p(X)),pos(p(Y))],[neg(p(U)),neg(p(V))]],[],S).
% S = [[]].

Ok, forgot about the occurs check.

This should also have either:
:- set_prolog_flag(occurs_check, true)

Or then sprinkled with calls to:
unify_occurs_check(_,_)

When variables occur non-linearly in a clause.

Mostowski Collapse schrieb am Donnerstag, 2. Juni 2022 um 21:03:37 UTC+2:
> Look Ma, a FOL resolution theorem prover in Prolog:
> See also: http://logic.stanford.edu/intrologic/chapters/chapter_14.html
>
> many([], S, S).
> many([C|T], S, R) :- next(C, T, S, R).
>
> next(C, T, S, R) :- member(D, S), weaker(D, C), !, many(T, S, R).
> next(C, T, S, R) :- filter(S, C, K), apply(C, K, H),
> append(T, H, J), many(J, [C|K], R).
>
> apply(C, S, T) :-
> findall(E, (member(D, S), resolvent(C, D, E)), T).
>
> resolvent(C, D, E) :-
> select(A, C, H), factor(A, H, C2),
> select(B, D, J), factor(B, J, D2),
> opposite(A, B),
> append(C2, D2, E).
>
> opposite(pos(A), neg(A)).
> opposite(neg(A), pos(A)).
>
> factor(_, C, C).
> factor(A, C, C2) :- select(A, C, H), factor(A, H, C2).
>
> filter([], _, []).
> filter([D|L], C, R) :- weaker(C, D), !, filter(L, C, R).
> filter([D|L], C, [D|R]) :- filter(L, C, R).
>
> weaker(C, D) :- \+ \+ (numbervars(D, 0, _), subset(C, D)).
>
> subset([], _).
> subset([X|L], R) :- member(X, R), subset(L, R).
>
> % ?- many([[pos(p(X)),pos(p(Y))],[neg(p(U)),neg(p(V))]],[],S).
> % S = [[]].

Corr.::

unify_with_occurs_check(_,_)

Mostowski Collapse schrieb am Freitag, 3. Juni 2022 um 11:44:20 UTC+2:
> Ok, forgot about the occurs check.
>
> This should also have either:
> :- set_prolog_flag(occurs_check, true)
>
> Or then sprinkled with calls to:
> unify_occurs_check(_,_)
>
> When variables occur non-linearly in a clause.
> Mostowski Collapse schrieb am Donnerstag, 2. Juni 2022 um 21:03:37 UTC+2:
> > Look Ma, a FOL resolution theorem prover in Prolog:
> > See also: http://logic.stanford.edu/intrologic/chapters/chapter_14.html
> >
> > many([], S, S).
> > many([C|T], S, R) :- next(C, T, S, R).
> >
> > next(C, T, S, R) :- member(D, S), weaker(D, C), !, many(T, S, R).
> > next(C, T, S, R) :- filter(S, C, K), apply(C, K, H),
> > append(T, H, J), many(J, [C|K], R).
> >
> > apply(C, S, T) :-
> > findall(E, (member(D, S), resolvent(C, D, E)), T).
> >
> > resolvent(C, D, E) :-
> > select(A, C, H), factor(A, H, C2),
> > select(B, D, J), factor(B, J, D2),
> > opposite(A, B),
> > append(C2, D2, E).
> >
> > opposite(pos(A), neg(A)).
> > opposite(neg(A), pos(A)).
> >
> > factor(_, C, C).
> > factor(A, C, C2) :- select(A, C, H), factor(A, H, C2).
> >
> > filter([], _, []).
> > filter([D|L], C, R) :- weaker(C, D), !, filter(L, C, R).
> > filter([D|L], C, [D|R]) :- filter(L, C, R).
> >
> > weaker(C, D) :- \+ \+ (numbervars(D, 0, _), subset(C, D)).
> >
> > subset([], _).
> > subset([X|L], R) :- member(X, R), subset(L, R).
> >
> > % ?- many([[pos(p(X)),pos(p(Y))],[neg(p(U)),neg(p(V))]],[],S).
> > % S = [[]].

My resolution theorem prover is an attempt to fix a bug
with Markus Triskas resolution theorem prover:

Resolution Calculus for Propositional Logic
pl_resolvent( ... ) :-
select(Q, As0, As),
select(not(Q), Bs0, Bs),
append(As, Bs, Rs0),
https://www.metalevel.at/logic/plres.pl

Mentioned here:

Theorem Proving with Prolog
https://www.metalevel.at/prolog/theoremproving

But when one reads the fine print by Markus Triska, it says
for propositional logic. Not sure whether it works for first
order logic (FOL) as well? There is a FOL example {p(X), p(Y)}

and {~p(U), ~p(V)} which hints that a full flegded resolution
theorem prover needs also “factoring”. Making a resolution
theorem prover only complete when it implements

resolution step with factoring:

> Φ
> ψ
> -------------------------------
> ((Φ’-{φ})∪(Ψ’-{¬ψ}))σ
> where τ is a variable renaming on Φ
> where Φ’ is a factor of Φτ and φ∈Φ’
> where Ψ’ is a factor of Ψ and ¬ψ∈Ψ’
> where σ=mgu(φ, ψ)
> http://logic.stanford.edu/intrologic/chapters/chapter_14.html

Any full fledged resolution theorem provers around written in Prolog?

Mostowski Collapse schrieb am Freitag, 3. Juni 2022 um 11:49:27 UTC+2:
> Corr.::
>
> unify_with_occurs_check(_,_)
> Mostowski Collapse schrieb am Freitag, 3. Juni 2022 um 11:44:20 UTC+2:
> > Ok, forgot about the occurs check.
> >
> > This should also have either:
> > :- set_prolog_flag(occurs_check, true)
> >
> > Or then sprinkled with calls to:
> > unify_occurs_check(_,_)
> >
> > When variables occur non-linearly in a clause.
> > Mostowski Collapse schrieb am Donnerstag, 2. Juni 2022 um 21:03:37 UTC+2:
> > > Look Ma, a FOL resolution theorem prover in Prolog:
> > > See also: http://logic.stanford.edu/intrologic/chapters/chapter_14.html
> > >
> > > many([], S, S).
> > > many([C|T], S, R) :- next(C, T, S, R).
> > >
> > > next(C, T, S, R) :- member(D, S), weaker(D, C), !, many(T, S, R).
> > > next(C, T, S, R) :- filter(S, C, K), apply(C, K, H),
> > > append(T, H, J), many(J, [C|K], R).
> > >
> > > apply(C, S, T) :-
> > > findall(E, (member(D, S), resolvent(C, D, E)), T).
> > >
> > > resolvent(C, D, E) :-
> > > select(A, C, H), factor(A, H, C2),
> > > select(B, D, J), factor(B, J, D2),
> > > opposite(A, B),
> > > append(C2, D2, E).
> > >
> > > opposite(pos(A), neg(A)).
> > > opposite(neg(A), pos(A)).
> > >
> > > factor(_, C, C).
> > > factor(A, C, C2) :- select(A, C, H), factor(A, H, C2).
> > >
> > > filter([], _, []).
> > > filter([D|L], C, R) :- weaker(C, D), !, filter(L, C, R).
> > > filter([D|L], C, [D|R]) :- filter(L, C, R).
> > >
> > > weaker(C, D) :- \+ \+ (numbervars(D, 0, _), subset(C, D)).
> > >
> > > subset([], _).
> > > subset([X|L], R) :- member(X, R), subset(L, R).
> > >
> > > % ?- many([[pos(p(X)),pos(p(Y))],[neg(p(U)),neg(p(V))]],[],S).
> > > % S = [[]].

Its 2022 and Prolog is among the top 20

TIOBE Index for June 2022
https://www.tiobe.com/tiobe-index/

Woa!

What would make sense, is a ISO core standard working
group, that would draft these stream creation properties:

- bom(Bool)
Specify detecting or writing a BOM.
- encoding(Atom)
Specify a file encoding.

After all we have already 2022 and 50 years of Prolog. But
can we be sure that Prolog texts are exchangeable, if
they use Unicode code points?

What if a UTF-16 file, handy for CJK, comes along?

Mostowski Collapse schrieb am Freitag, 10. Juni 2022 um 14:54:07 UTC+2:
> Its 2022 and Prolog is among the top 20
>
> TIOBE Index for June 2022
> https://www.tiobe.com/tiobe-index/
>
> Woa!

I feel I have not the according experience. Will redo this
stuff now for Dogelog Player after having it in formerly
Jekejeke Prolog and still discovering new corners. Maybe

can tell more in a few years. Also experience from formerly
Jekejeke Prolog are that things might look different for
UrlConnection, since the server might do the BOM detection

and the client doesn’t need. I guess SWI-Prolog has also
some experience here through http_open/3.

Mostowski Collapse schrieb am Samstag, 25. Juni 2022 um 11:39:42 UTC+2:
> What would make sense, is a ISO core standard working
> group, that would draft these stream creation properties:
>
> - bom(Bool)
> Specify detecting or writing a BOM.
> - encoding(Atom)
> Specify a file encoding.
>
> After all we have already 2022 and 50 years of Prolog. But
> can we be sure that Prolog texts are exchangeable, if
> they use Unicode code points?
>
> What if a UTF-16 file, handy for CJK, comes along?
> Mostowski Collapse schrieb am Freitag, 10. Juni 2022 um 14:54:07 UTC+2:
> > Its 2022 and Prolog is among the top 20
> >
> > TIOBE Index for June 2022
> > https://www.tiobe.com/tiobe-index/
> >
> > Woa!

An ode to the most annoying people in Prolog:

Markus Triska, this wasn't my question. On the same grounds
you could remove (\+)/1 from Prolog. Doesn't make any sense
what you write since Prolog has dual use, pure and impure.

If you want to provide a fully pure language you have to
rename Scryer Prolog into something Scryer XXX, where
XXX is this language. And if your attempt is at a pure language

that is also aimed at bootstrapping the system itself, then
you have to demonstrate this for your XXX. But to the best of
my knowledge it is still called Scryer Prolog and not

Scryer XXX and I do not find a single paper about some XXX
that would be the basis for this utopian Scryer XXX from nowhere
land. Scryer Prolog rather refers repeatedly to WAM which supports

the cut and friends. What is your XXX exactly? Your bragging seems
rather moot and annoying nonsense in the context of Scryer Prolog
which is based on WAM. If this were a repository of another language

dedicated to this Scryer XXX, your comments would make sense.
But as they are now distributed all over the place, they rather
look like disorganized debris to me, that landed in the wrong place.

Maybe open a new repository for your Scryer XXX instead of
bothering people with your ever repeating nonsense, that is
anyway trivially evident for any Prologer who knows his cut?

Ignoring the users of a Prolog system was always a good strategy:

And? Whats your point exactly? The same happens here:

?- nonvar(X).
false.

?- X = a, nonvar(X).
X = a.

Do you also suggest to remove nonvar/1. nonvar/1 is part of the
ISO core standard. forall/2 can be found in this document:

New built-in flags, predicates, and functions proposal
8.10.4 forall/2
ISO/IEC DTR 13211-1:2006
https://www.complang.tuwien.ac.at/ulrich/iso-prolog/N208

Which had these people behind it, potential users of it:

Bart Demoen (Belgium)
Jan Wielemaker, (Netherlands)
Joachim Schimpf (UK)
Jonathan Hodgson (USA)
Katsuhiko Nakamura (Japan)
Klaus Daessler (Germany)
Mary Kroening (USA)
Michael Covington (USA)
Neng-Fu Zhou (USA)
Paulo Moura (Portugal)
Pierre Deransart (France)
Péter Szabó (Hungary)
Péter Szeredi (Hungary)
Rémy Haemmerlé (France)
Richard O'Keefe (NZ)
Roberto Bagnara (Italy)
Roger Scowen (UK)
Ulrich Neumerkel (Austria)

So its one, Markus Triska, against many. I am only
voicing what many expect anyway from a Prolog system.

Make a GitHub search, you find many places where it is used
by some Prolog programmer. Its kind of staple food.

Mostowski Collapse schrieb am Dienstag, 12. Juli 2022 um 09:45:36 UTC+2:
> An ode to the most annoying people in Prolog:
>
> Markus Triska, this wasn't my question. On the same grounds
> you could remove (\+)/1 from Prolog. Doesn't make any sense
> what you write since Prolog has dual use, pure and impure.
>
> If you want to provide a fully pure language you have to
> rename Scryer Prolog into something Scryer XXX, where
> XXX is this language. And if your attempt is at a pure language
>
> that is also aimed at bootstrapping the system itself, then
> you have to demonstrate this for your XXX. But to the best of
> my knowledge it is still called Scryer Prolog and not
>
> Scryer XXX and I do not find a single paper about some XXX
> that would be the basis for this utopian Scryer XXX from nowhere
> land. Scryer Prolog rather refers repeatedly to WAM which supports
>
> the cut and friends. What is your XXX exactly? Your bragging seems
> rather moot and annoying nonsense in the context of Scryer Prolog
> which is based on WAM. If this were a repository of another language
>
> dedicated to this Scryer XXX, your comments would make sense.
> But as they are now distributed all over the place, they rather
> look like disorganized debris to me, that landed in the wrong place.
>
> Maybe open a new repository for your Scryer XXX instead of
> bothering people with your ever repeating nonsense, that is
> anyway trivially evident for any Prologer who knows his cut?

Here is a suggestion to stop this madness:

SWI-Prolog has an iso marker, which is seen in its
documentation. Scryer Prolog seems to have two
kinds of users. a) Ordinary Prolog users, and b)

Users that project some more Declarative Language into
Scryer Prolog, although Scryer Prolog is based on
WAM which is not designed for that. Maybe introduce

an impure marker so that we can identify the subset
of this upcoming more Declarative Language. This
could be more helpful than distracting GitHub issues

that adresse the ordinary needs of Prolog programmers
by posting trivialities that anyway any Prologer knows. Here
is my suggestion, predicates could be marked as follows:

','/2: no marker
(\+)/1: impure marker
nonvar/1: impure marker
Etc...

One could then generate an index with the pure predicates
that do not have the impure marker. Is there already a booklet
about this new extra ordinary language somewhere?

It would be interesting to see what language results by this index.
Is it possible to bootstrap a Prolog system with this language?
Does it contain some novel declarative predicates?

Also the idea that Scryer Prolog would not support the
needs of ordinary Prolog programmers and is kind of
extra ordinary language runs counter to its own slogan.

It says the first line of the GitHub readme:

Scryer Prolog
Scryer Prolog aims to become to ISO Prolog what GHC is to Haskell:
https://github.com/mthom/scryer-prolog

So it subscribes to ISO Prolog which is anyway dual use,
impure and pure. I do not find that the ISO core standard
would only promote pure Prolog.

Scryer Prolog might be a test bed for some new upcoming
declarative programming language. But then the slogan has
probably to be changed if this test bed gets hijacked into

an exclusive discriminating venture. If the marking doesn't
work, maybe a side project with new Prolog system
XXX could be interesting. Where effectively the

impure predicates are blocked. This could be an interesting
idea, so there would be also download of XXX, which
is pure, and end-users would have no way to change that,

kind of relaunch of the Gödel language idea:

The Gödel Programming Language (Logic Programming)
von Patricia Hill (Author), John W. Lloyd (Author)
https://www.amazon.com/dp/0262082292

which had a similar aim.

Mostowski Collapse schrieb am Dienstag, 12. Juli 2022 um 10:28:22 UTC+2:
> Here is a suggestion to stop this madness:
>
>
> SWI-Prolog has an iso marker, which is seen in its
> documentation. Scryer Prolog seems to have two
> kinds of users. a) Ordinary Prolog users, and b)
>
> Users that project some more Declarative Language into
> Scryer Prolog, although Scryer Prolog is based on
> WAM which is not designed for that. Maybe introduce
>
> an impure marker so that we can identify the subset
> of this upcoming more Declarative Language. This
> could be more helpful than distracting GitHub issues
>
> that adresse the ordinary needs of Prolog programmers
> by posting trivialities that anyway any Prologer knows. Here
> is my suggestion, predicates could be marked as follows:
>
> ','/2: no marker
> (\+)/1: impure marker
> nonvar/1: impure marker
> Etc...
>
> One could then generate an index with the pure predicates
> that do not have the impure marker. Is there already a booklet
> about this new extra ordinary language somewhere?
>
> It would be interesting to see what language results by this index.
> Is it possible to bootstrap a Prolog system with this language?
> Does it contain some novel declarative predicates?

Even in 2018 People ask:

I want to start programming with Gödel language
Kurt Gödel, LQ Newbie - 02-24-2018, 09:41 AM
"I don’t know anything about computer programming.
So here I need help please explain to me how computers work.
I found this language called gödel,
but is this the language i can create a game with?
And I do want to know where can I go to learn programming."
https://www.linuxquestions.org/questions/programming-9/i-want-to-start-programming-with-g%F6del-language-4175624376/

Call the Scryer derived language Gödel II, how about that?

Mostowski Collapse schrieb am Dienstag, 12. Juli 2022 um 10:29:00 UTC+2:
> Also the idea that Scryer Prolog would not support the
> needs of ordinary Prolog programmers and is kind of
> extra ordinary language runs counter to its own slogan.
>
> It says the first line of the GitHub readme:
>
> Scryer Prolog
> Scryer Prolog aims to become to ISO Prolog what GHC is to Haskell:
> https://github.com/mthom/scryer-prolog
>
> So it subscribes to ISO Prolog which is anyway dual use,
> impure and pure. I do not find that the ISO core standard
> would only promote pure Prolog.
>
> Scryer Prolog might be a test bed for some new upcoming
> declarative programming language. But then the slogan has
> probably to be changed if this test bed gets hijacked into
>
> an exclusive discriminating venture. If the marking doesn't
> work, maybe a side project with new Prolog system
> XXX could be interesting. Where effectively the
>
> impure predicates are blocked. This could be an interesting
> idea, so there would be also download of XXX, which
> is pure, and end-users would have no way to change that,
>
> kind of relaunch of the Gödel language idea:
>
> The Gödel Programming Language (Logic Programming)
> von Patricia Hill (Author), John W. Lloyd (Author)
> https://www.amazon.com/dp/0262082292
>
> which had a similar aim.
> Mostowski Collapse schrieb am Dienstag, 12. Juli 2022 um 10:28:22 UTC+2:
> > Here is a suggestion to stop this madness:
> >
> >
> > SWI-Prolog has an iso marker, which is seen in its
> > documentation. Scryer Prolog seems to have two
> > kinds of users. a) Ordinary Prolog users, and b)
> >
> > Users that project some more Declarative Language into
> > Scryer Prolog, although Scryer Prolog is based on
> > WAM which is not designed for that. Maybe introduce
> >
> > an impure marker so that we can identify the subset
> > of this upcoming more Declarative Language. This
> > could be more helpful than distracting GitHub issues
> >
> > that adresse the ordinary needs of Prolog programmers
> > by posting trivialities that anyway any Prologer knows. Here
> > is my suggestion, predicates could be marked as follows:
> >
> > ','/2: no marker
> > (\+)/1: impure marker
> > nonvar/1: impure marker
> > Etc...
> >
> > One could then generate an index with the pure predicates
> > that do not have the impure marker. Is there already a booklet
> > about this new extra ordinary language somewhere?
> >
> > It would be interesting to see what language results by this index.
> > Is it possible to bootstrap a Prolog system with this language?
> > Does it contain some novel declarative predicates?

Mostowski Collapse <bursejan@gmail.com> writes:

> Which had these people behind it, potential users of it:

However, not everyone in this list supports everything in the document.
And the document is from 14 years ago: Back then, important constructs
such as if_/3, tfilter/3 etc. were not even found, and the quest for
better constructs was quite stalled. We can do better today than many of
us thought possible in 2008, or even in 2016: For example, just in these
last 6 years, we got 4 new Prolog systems (Scryer, Trealla, Tau and
ichiban/prolog) where double_quotes is set to chars by default. Who
thought that this was possible in 2008? I think even in 2012 or even
later, implementors advocated for JavaScript-style "strings" in Prolog
and even added them to their systems, until a new representation
pioneered by Scryer Prolog made chars viable in newer systems. forall/2
probably likewise seemed necessary in 2008, but does it still seem so
today? A better, not yet found construct, could likewise make it
obsolete, just like JavaScript-style strings have now become obsolete.

> Make a GitHub search, you find many places where it is used
> by some Prolog programmer. Its kind of staple food.

You will find a lot on GitHub, a lot of Java and C code too. It could
make for an interesting analysis, however I find decisions based on such
statistics subject to certain doubts: For example, is a construct that
violates elementary logical properties good because it appears in a lot
of programs? Or does this rather show that many programs could be
improved by removing this construct entirely from the language?

All the best,
Markus

--
comp.lang.prolog FAQ: http://www.logic.at/prolog/faq/
The Power of Prolog: https://www.metalevel.at/prolog

Well the error is always the programmer, in this
case the programmer doesnt know that in Prolog
bound variables have to be „ purified“ i.e. given

different names. For example spinning your nonsense
further far ahead, you could also demand to ban
findall from Prolog, because:

?- findall(X, member(X, [1,4,2], L).
L = [1, 4, 2]

X is not instantiated in the answer, so by monotonicity,
we should be able to instantiate it, but it goes wrong:

?- X = 3, findall(X, member(X, [1,4,2], L).
fail

Separating away variable names is bread and butter in
theorem proving. I dont think double_quotes chars value
is a contribution here, neither if_ etc.

I dont find any proposal for an improvement either in
the new Prolog systems like Trealla, Scryer, etc..

I only find turds on GitHub all over the place forbid
this forbid that despite there is not a single outcry
by other Prolog programmers that variable

purification is not a body convesion step in ISO standard
Prolog. Write please an amendmend to the ISO standard
or define a new language with automatic variable

separation and then we can talk again.

P.S.: Lambda Prolog can do it. But you would write
findall invocation slightly differently.

Markus Triska schrieb am Dienstag, 12. Juli 2022 um 19:21:23 UTC+2:
> Mostowski Collapse <burs...@gmail.com> writes:
>
> > Which had these people behind it, potential users of it:
> However, not everyone in this list supports everything in the document.
> And the document is from 14 years ago: Back then, important constructs
> such as if_/3, tfilter/3 etc. were not even found, and the quest for
> better constructs was quite stalled. We can do better today than many of
> us thought possible in 2008, or even in 2016: For example, just in these
> last 6 years, we got 4 new Prolog systems (Scryer, Trealla, Tau and
> ichiban/prolog) where double_quotes is set to chars by default. Who
> thought that this was possible in 2008? I think even in 2012 or even
> later, implementors advocated for JavaScript-style "strings" in Prolog
> and even added them to their systems, until a new representation
> pioneered by Scryer Prolog made chars viable in newer systems. forall/2
> probably likewise seemed necessary in 2008, but does it still seem so
> today? A better, not yet found construct, could likewise make it
> obsolete, just like JavaScript-style strings have now become obsolete.
> > Make a GitHub search, you find many places where it is used
> > by some Prolog programmer. Its kind of staple food.
> You will find a lot on GitHub, a lot of Java and C code too. It could
> make for an interesting analysis, however I find decisions based on such
> statistics subject to certain doubts: For example, is a construct that
> violates elementary logical properties good because it appears in a lot
> of programs? Or does this rather show that many programs could be
> improved by removing this construct entirely from the language?
>
> All the best,
> Markus
>
> --
> comp.lang.prolog FAQ: http://www.logic.at/prolog/faq/
> The Power of Prolog: https://www.metalevel.at/prolog

In Lambda Prolog you could define a findall
by accempting a higher order closure using
some lambda binder, here I am using (\)/2 for

this purpose. findall would only have arity 2:

?- findall(X\member(X, [1,4,2]), L).
L = [1, 4, 2]
?- X = 3, findall(X\member(X, [1,4,2]), L).
X = 3,
L = [1, 4, 2]

But you have to rethink your logic programming
language from ground up. You might need a different
read term, or some post processing of read term.

Lambda Prolog does all that. But posting turds on GitHub
does nothing. It only shows that you are ignorant about
possible solutions that exist since Alonzo Church,

https://en.m.wikipedia.org/wiki/Alonzo_Church

The solutions are older than the 50 years of prolog.

Mostowski Collapse schrieb am Dienstag, 12. Juli 2022 um 23:50:20 UTC+2:
> Well the error is always the programmer, in this
> case the programmer doesnt know that in Prolog
> bound variables have to be „ purified“ i.e. given
>
> different names. For example spinning your nonsense
> further far ahead, you could also demand to ban
> findall from Prolog, because:
>
> ?- findall(X, member(X, [1,4,2], L).
> L = [1, 4, 2]
>
> X is not instantiated in the answer, so by monotonicity,
> we should be able to instantiate it, but it goes wrong:
>
> ?- X = 3, findall(X, member(X, [1,4,2], L).
> fail
>
> Separating away variable names is bread and butter in
> theorem proving. I dont think double_quotes chars value
> is a contribution here, neither if_ etc.
>
> I dont find any proposal for an improvement either in
> the new Prolog systems like Trealla, Scryer, etc..
>
> I only find turds on GitHub all over the place forbid
> this forbid that despite there is not a single outcry
> by other Prolog programmers that variable
>
> purification is not a body convesion step in ISO standard
> Prolog. Write please an amendmend to the ISO standard
> or define a new language with automatic variable
>
> separation and then we can talk again.
>
> P.S.: Lambda Prolog can do it. But you would write
> findall invocation slightly differently.
> Markus Triska schrieb am Dienstag, 12. Juli 2022 um 19:21:23 UTC+2:
> > Mostowski Collapse <burs...@gmail.com> writes:
> >
> > > Which had these people behind it, potential users of it:
> > However, not everyone in this list supports everything in the document.
> > And the document is from 14 years ago: Back then, important constructs
> > such as if_/3, tfilter/3 etc. were not even found, and the quest for
> > better constructs was quite stalled. We can do better today than many of
> > us thought possible in 2008, or even in 2016: For example, just in these
> > last 6 years, we got 4 new Prolog systems (Scryer, Trealla, Tau and
> > ichiban/prolog) where double_quotes is set to chars by default. Who
> > thought that this was possible in 2008? I think even in 2012 or even
> > later, implementors advocated for JavaScript-style "strings" in Prolog
> > and even added them to their systems, until a new representation
> > pioneered by Scryer Prolog made chars viable in newer systems. forall/2
> > probably likewise seemed necessary in 2008, but does it still seem so
> > today? A better, not yet found construct, could likewise make it
> > obsolete, just like JavaScript-style strings have now become obsolete.
> > > Make a GitHub search, you find many places where it is used
> > > by some Prolog programmer. Its kind of staple food.
> > You will find a lot on GitHub, a lot of Java and C code too. It could
> > make for an interesting analysis, however I find decisions based on such
> > statistics subject to certain doubts: For example, is a construct that
> > violates elementary logical properties good because it appears in a lot
> > of programs? Or does this rather show that many programs could be
> > improved by removing this construct entirely from the language?
> >
> > All the best,
> > Markus
> >
> > --
> > comp.lang.prolog FAQ: http://www.logic.at/prolog/faq/
> > The Power of Prolog: https://www.metalevel.at/prolog

Corr.: Currently in Prolog we would have:

?- X = 3, findall(X, member(X, [1,4,2]), L).
X = 3,
L = []

In as far forall/2 has a similar „problem“
which is usually taken care by the programmer,
similarly like the programmer watches

that his findalls are purified according to the
use case he has. Etc.. etc… But compared
to Lambda Prolog ordinary prolog is

more primitive and has primafacie some inference
rules missing, although a lot can be compensated by
meta interpreters, little theorem provers, little

new languages written in Prolog itself. But these little
tools might be impure. Some lamda Prolog through its
HOAS can enforce meta circular purity. Here I

totally agree that Prolog lacks this feature. But you cannot
add this feature by forbidding things as you do. Compared
to Lamda Prolog your approach of turding Prolog

by disrupting GitHub with crazy comments and
no contribution has zero impact on improving the
situation. Its just nonsense.

Mostowski Collapse schrieb am Mittwoch, 13. Juli 2022 um 00:01:29 UTC+2:
> In Lambda Prolog you could define a findall
> by accempting a higher order closure using
> some lambda binder, here I am using (\)/2 for
>
> this purpose. findall would only have arity 2:
>
> ?- findall(X\member(X, [1,4,2]), L).
> L = [1, 4, 2]
> ?- X = 3, findall(X\member(X, [1,4,2]), L).
> X = 3,
> L = [1, 4, 2]
> But you have to rethink your logic programming
> language from ground up. You might need a different
> read term, or some post processing of read term.
>
> Lambda Prolog does all that. But posting turds on GitHub
> does nothing. It only shows that you are ignorant about
> possible solutions that exist since Alonzo Church,
>
> https://en.m.wikipedia.org/wiki/Alonzo_Church
>
> The solutions are older than the 50 years of prolog.
> Mostowski Collapse schrieb am Dienstag, 12. Juli 2022 um 23:50:20 UTC+2:
> > Well the error is always the programmer, in this
> > case the programmer doesnt know that in Prolog
> > bound variables have to be „ purified“ i.e. given
> >
> > different names. For example spinning your nonsense
> > further far ahead, you could also demand to ban
> > findall from Prolog, because:
> >
> > ?- findall(X, member(X, [1,4,2], L).
> > L = [1, 4, 2]
> >
> > X is not instantiated in the answer, so by monotonicity,
> > we should be able to instantiate it, but it goes wrong:
> >
> > ?- X = 3, findall(X, member(X, [1,4,2], L).
> > fail
> >
> > Separating away variable names is bread and butter in
> > theorem proving. I dont think double_quotes chars value
> > is a contribution here, neither if_ etc.
> >
> > I dont find any proposal for an improvement either in
> > the new Prolog systems like Trealla, Scryer, etc..
> >
> > I only find turds on GitHub all over the place forbid
> > this forbid that despite there is not a single outcry
> > by other Prolog programmers that variable
> >
> > purification is not a body convesion step in ISO standard
> > Prolog. Write please an amendmend to the ISO standard
> > or define a new language with automatic variable
> >
> > separation and then we can talk again.
> >
> > P.S.: Lambda Prolog can do it. But you would write
> > findall invocation slightly differently.
> > Markus Triska schrieb am Dienstag, 12. Juli 2022 um 19:21:23 UTC+2:
> > > Mostowski Collapse <burs...@gmail.com> writes:
> > >
> > > > Which had these people behind it, potential users of it:
> > > However, not everyone in this list supports everything in the document.
> > > And the document is from 14 years ago: Back then, important constructs
> > > such as if_/3, tfilter/3 etc. were not even found, and the quest for
> > > better constructs was quite stalled. We can do better today than many of
> > > us thought possible in 2008, or even in 2016: For example, just in these
> > > last 6 years, we got 4 new Prolog systems (Scryer, Trealla, Tau and
> > > ichiban/prolog) where double_quotes is set to chars by default. Who
> > > thought that this was possible in 2008? I think even in 2012 or even
> > > later, implementors advocated for JavaScript-style "strings" in Prolog
> > > and even added them to their systems, until a new representation
> > > pioneered by Scryer Prolog made chars viable in newer systems. forall/2
> > > probably likewise seemed necessary in 2008, but does it still seem so
> > > today? A better, not yet found construct, could likewise make it
> > > obsolete, just like JavaScript-style strings have now become obsolete..
> > > > Make a GitHub search, you find many places where it is used
> > > > by some Prolog programmer. Its kind of staple food.
> > > You will find a lot on GitHub, a lot of Java and C code too. It could
> > > make for an interesting analysis, however I find decisions based on such
> > > statistics subject to certain doubts: For example, is a construct that
> > > violates elementary logical properties good because it appears in a lot
> > > of programs? Or does this rather show that many programs could be
> > > improved by removing this construct entirely from the language?
> > >
> > > All the best,
> > > Markus
> > >
> > > --
> > > comp.lang.prolog FAQ: http://www.logic.at/prolog/faq/
> > > The Power of Prolog: https://www.metalevel.at/prolog

Also the uses of forall/2 have increased in the past.
Some people use it as a replacement for failure driven loop:

?- G, C, fail; true.

They write it as:

?- forall(G, C).

It has the advantage/disadvantage that it signals
failure of C. Which the failure driven loop does not do.
You find it in the wild here:

main :-
forall(number_fizzbuzz_below_100(_, FizzBuzz),
(write(FizzBuzz), write('\n'))).

https://github.com/triska/clpz/issues/12

Its from some of your users of Scryer Prolog
and some of your users of CLP(Z). So I guess
you dont know who your users are?

Good luck with that…
You are Genius like Putin.

Mostowski Collapse schrieb am Mittwoch, 13. Juli 2022 um 00:17:00 UTC+2:
> Corr.: Currently in Prolog we would have:
>
> ?- X = 3, findall(X, member(X, [1,4,2]), L).
> X = 3,
> L = []
>
> In as far forall/2 has a similar „problem“
> which is usually taken care by the programmer,
> similarly like the programmer watches
>
> that his findalls are purified according to the
> use case he has. Etc.. etc… But compared
> to Lambda Prolog ordinary prolog is
>
> more primitive and has primafacie some inference
> rules missing, although a lot can be compensated by
> meta interpreters, little theorem provers, little
>
> new languages written in Prolog itself. But these little
> tools might be impure. Some lamda Prolog through its
> HOAS can enforce meta circular purity. Here I
>
> totally agree that Prolog lacks this feature. But you cannot
> add this feature by forbidding things as you do. Compared
> to Lamda Prolog your approach of turding Prolog
>
> by disrupting GitHub with crazy comments and
> no contribution has zero impact on improving the
> situation. Its just nonsense.
> Mostowski Collapse schrieb am Mittwoch, 13. Juli 2022 um 00:01:29 UTC+2:
> > In Lambda Prolog you could define a findall
> > by accempting a higher order closure using
> > some lambda binder, here I am using (\)/2 for
> >
> > this purpose. findall would only have arity 2:
> >
> > ?- findall(X\member(X, [1,4,2]), L).
> > L = [1, 4, 2]
> > ?- X = 3, findall(X\member(X, [1,4,2]), L).
> > X = 3,
> > L = [1, 4, 2]
> > But you have to rethink your logic programming
> > language from ground up. You might need a different
> > read term, or some post processing of read term.
> >
> > Lambda Prolog does all that. But posting turds on GitHub
> > does nothing. It only shows that you are ignorant about
> > possible solutions that exist since Alonzo Church,
> >
> > https://en.m.wikipedia.org/wiki/Alonzo_Church
> >
> > The solutions are older than the 50 years of prolog.
> > Mostowski Collapse schrieb am Dienstag, 12. Juli 2022 um 23:50:20 UTC+2:
> > > Well the error is always the programmer, in this
> > > case the programmer doesnt know that in Prolog
> > > bound variables have to be „ purified“ i.e. given
> > >
> > > different names. For example spinning your nonsense
> > > further far ahead, you could also demand to ban
> > > findall from Prolog, because:
> > >
> > > ?- findall(X, member(X, [1,4,2], L).
> > > L = [1, 4, 2]
> > >
> > > X is not instantiated in the answer, so by monotonicity,
> > > we should be able to instantiate it, but it goes wrong:
> > >
> > > ?- X = 3, findall(X, member(X, [1,4,2], L).
> > > fail
> > >
> > > Separating away variable names is bread and butter in
> > > theorem proving. I dont think double_quotes chars value
> > > is a contribution here, neither if_ etc.
> > >
> > > I dont find any proposal for an improvement either in
> > > the new Prolog systems like Trealla, Scryer, etc..
> > >
> > > I only find turds on GitHub all over the place forbid
> > > this forbid that despite there is not a single outcry
> > > by other Prolog programmers that variable
> > >
> > > purification is not a body convesion step in ISO standard
> > > Prolog. Write please an amendmend to the ISO standard
> > > or define a new language with automatic variable
> > >
> > > separation and then we can talk again.
> > >
> > > P.S.: Lambda Prolog can do it. But you would write
> > > findall invocation slightly differently.
> > > Markus Triska schrieb am Dienstag, 12. Juli 2022 um 19:21:23 UTC+2:
> > > > Mostowski Collapse <burs...@gmail.com> writes:
> > > >
> > > > > Which had these people behind it, potential users of it:
> > > > However, not everyone in this list supports everything in the document.
> > > > And the document is from 14 years ago: Back then, important constructs
> > > > such as if_/3, tfilter/3 etc. were not even found, and the quest for
> > > > better constructs was quite stalled. We can do better today than many of
> > > > us thought possible in 2008, or even in 2016: For example, just in these
> > > > last 6 years, we got 4 new Prolog systems (Scryer, Trealla, Tau and
> > > > ichiban/prolog) where double_quotes is set to chars by default. Who
> > > > thought that this was possible in 2008? I think even in 2012 or even
> > > > later, implementors advocated for JavaScript-style "strings" in Prolog
> > > > and even added them to their systems, until a new representation
> > > > pioneered by Scryer Prolog made chars viable in newer systems. forall/2
> > > > probably likewise seemed necessary in 2008, but does it still seem so
> > > > today? A better, not yet found construct, could likewise make it
> > > > obsolete, just like JavaScript-style strings have now become obsolete.
> > > > > Make a GitHub search, you find many places where it is used
> > > > > by some Prolog programmer. Its kind of staple food.
> > > > You will find a lot on GitHub, a lot of Java and C code too. It could
> > > > make for an interesting analysis, however I find decisions based on such
> > > > statistics subject to certain doubts: For example, is a construct that
> > > > violates elementary logical properties good because it appears in a lot
> > > > of programs? Or does this rather show that many programs could be
> > > > improved by removing this construct entirely from the language?
> > > >
> > > > All the best,
> > > > Markus
> > > >
> > > > --
> > > > comp.lang.prolog FAQ: http://www.logic.at/prolog/faq/
> > > > The Power of Prolog: https://www.metalevel.at/prolog

Also there are quite capable people in the SWI Prolog
discourse group, that where discussing forall/2
versus foreach/2, repeatedly showing some

deep understanding of the constructs, which I find
lacking if somebody critizises the construct based
on a usage error in the form

of lack of purification. That paints one into a corner
of not understanding the construct at all. Last but
not least s(CASP) starting with s(ASP),

have also found uses for some forms of forall/2.
Just read the papers follow the forums and
inspect the systems. forall/2 has

come to amazing new life. forall is also
not the worst name of the predicate, since it can
provide the so called bounded universal quantifier,

under certain circumstances you can tranlate it
(this is left as an exercise):

ALL(x):[A => B]

But I have recently started calling it Peano
implication, since Giuseppe Peano used the
following notation for it:

A =>x B

putting more emphasis on the underlying
implication than on the universally
bound variable.

Have Fun!

Mostowski Collapse schrieb am Mittwoch, 13. Juli 2022 um 01:02:47 UTC+2:
> Also the uses of forall/2 have increased in the past.
> Some people use it as a replacement for failure driven loop:
>
> ?- G, C, fail; true.
>
> They write it as:
>
> ?- forall(G, C).
>
> It has the advantage/disadvantage that it signals
> failure of C. Which the failure driven loop does not do.
> You find it in the wild here:
>
> main :-
> forall(number_fizzbuzz_below_100(_, FizzBuzz),
> (write(FizzBuzz), write('\n'))).
>
> https://github.com/triska/clpz/issues/12
>
> Its from some of your users of Scryer Prolog
> and some of your users of CLP(Z). So I guess
> you dont know who your users are?
>
> Good luck with that…
> You are Genius like Putin.
> Mostowski Collapse schrieb am Mittwoch, 13. Juli 2022 um 00:17:00 UTC+2:
> > Corr.: Currently in Prolog we would have:
> >
> > ?- X = 3, findall(X, member(X, [1,4,2]), L).
> > X = 3,
> > L = []
> >
> > In as far forall/2 has a similar „problem“
> > which is usually taken care by the programmer,
> > similarly like the programmer watches
> >
> > that his findalls are purified according to the
> > use case he has. Etc.. etc… But compared
> > to Lambda Prolog ordinary prolog is
> >
> > more primitive and has primafacie some inference
> > rules missing, although a lot can be compensated by
> > meta interpreters, little theorem provers, little
> >
> > new languages written in Prolog itself. But these little
> > tools might be impure. Some lamda Prolog through its
> > HOAS can enforce meta circular purity. Here I
> >
> > totally agree that Prolog lacks this feature. But you cannot
> > add this feature by forbidding things as you do. Compared
> > to Lamda Prolog your approach of turding Prolog
> >
> > by disrupting GitHub with crazy comments and
> > no contribution has zero impact on improving the
> > situation. Its just nonsense.
> > Mostowski Collapse schrieb am Mittwoch, 13. Juli 2022 um 00:01:29 UTC+2:
> > > In Lambda Prolog you could define a findall
> > > by accempting a higher order closure using
> > > some lambda binder, here I am using (\)/2 for
> > >
> > > this purpose. findall would only have arity 2:
> > >
> > > ?- findall(X\member(X, [1,4,2]), L).
> > > L = [1, 4, 2]
> > > ?- X = 3, findall(X\member(X, [1,4,2]), L).
> > > X = 3,
> > > L = [1, 4, 2]
> > > But you have to rethink your logic programming
> > > language from ground up. You might need a different
> > > read term, or some post processing of read term.
> > >
> > > Lambda Prolog does all that. But posting turds on GitHub
> > > does nothing. It only shows that you are ignorant about
> > > possible solutions that exist since Alonzo Church,
> > >
> > > https://en.m.wikipedia.org/wiki/Alonzo_Church
> > >
> > > The solutions are older than the 50 years of prolog.
> > > Mostowski Collapse schrieb am Dienstag, 12. Juli 2022 um 23:50:20 UTC+2:
> > > > Well the error is always the programmer, in this
> > > > case the programmer doesnt know that in Prolog
> > > > bound variables have to be „ purified“ i.e. given
> > > >
> > > > different names. For example spinning your nonsense
> > > > further far ahead, you could also demand to ban
> > > > findall from Prolog, because:
> > > >
> > > > ?- findall(X, member(X, [1,4,2], L).
> > > > L = [1, 4, 2]
> > > >
> > > > X is not instantiated in the answer, so by monotonicity,
> > > > we should be able to instantiate it, but it goes wrong:
> > > >
> > > > ?- X = 3, findall(X, member(X, [1,4,2], L).
> > > > fail
> > > >
> > > > Separating away variable names is bread and butter in
> > > > theorem proving. I dont think double_quotes chars value
> > > > is a contribution here, neither if_ etc.
> > > >
> > > > I dont find any proposal for an improvement either in
> > > > the new Prolog systems like Trealla, Scryer, etc..
> > > >
> > > > I only find turds on GitHub all over the place forbid
> > > > this forbid that despite there is not a single outcry
> > > > by other Prolog programmers that variable
> > > >
> > > > purification is not a body convesion step in ISO standard
> > > > Prolog. Write please an amendmend to the ISO standard
> > > > or define a new language with automatic variable
> > > >
> > > > separation and then we can talk again.
> > > >
> > > > P.S.: Lambda Prolog can do it. But you would write
> > > > findall invocation slightly differently.
> > > > Markus Triska schrieb am Dienstag, 12. Juli 2022 um 19:21:23 UTC+2:
> > > > > Mostowski Collapse <burs...@gmail.com> writes:
> > > > >
> > > > > > Which had these people behind it, potential users of it:
> > > > > However, not everyone in this list supports everything in the document.
> > > > > And the document is from 14 years ago: Back then, important constructs
> > > > > such as if_/3, tfilter/3 etc. were not even found, and the quest for
> > > > > better constructs was quite stalled. We can do better today than many of
> > > > > us thought possible in 2008, or even in 2016: For example, just in these
> > > > > last 6 years, we got 4 new Prolog systems (Scryer, Trealla, Tau and
> > > > > ichiban/prolog) where double_quotes is set to chars by default. Who
> > > > > thought that this was possible in 2008? I think even in 2012 or even
> > > > > later, implementors advocated for JavaScript-style "strings" in Prolog
> > > > > and even added them to their systems, until a new representation
> > > > > pioneered by Scryer Prolog made chars viable in newer systems. forall/2
> > > > > probably likewise seemed necessary in 2008, but does it still seem so
> > > > > today? A better, not yet found construct, could likewise make it
> > > > > obsolete, just like JavaScript-style strings have now become obsolete.
> > > > > > Make a GitHub search, you find many places where it is used
> > > > > > by some Prolog programmer. Its kind of staple food.
> > > > > You will find a lot on GitHub, a lot of Java and C code too. It could
> > > > > make for an interesting analysis, however I find decisions based on such
> > > > > statistics subject to certain doubts: For example, is a construct that
> > > > > violates elementary logical properties good because it appears in a lot
> > > > > of programs? Or does this rather show that many programs could be
> > > > > improved by removing this construct entirely from the language?
> > > > >
> > > > > All the best,
> > > > > Markus
> > > > >
> > > > > --
> > > > > comp.lang.prolog FAQ: http://www.logic.at/prolog/faq/
> > > > > The Power of Prolog: https://www.metalevel.at/prolog

Peanos conditional made it
even into the Principia Mathematica:

Before we look at a wider range of examples, a detailed
example involving quantified variables will prove to be
instructive. Whitehead and Russell follow Peano’s

practice of expressing universally quantified conditionals
(such as “All ps are qs”) with the bound variable
subscripted under the conditional sign.

https://plato.stanford.edu/entries/pm-notation/#Exam

Lets make Peano great again!

Mostowski Collapse schrieb am Mittwoch, 13. Juli 2022 um 01:22:27 UTC+2:
> Also there are quite capable people in the SWI Prolog
> discourse group, that where discussing forall/2
> versus foreach/2, repeatedly showing some
>
> deep understanding of the constructs, which I find
> lacking if somebody critizises the construct based
> on a usage error in the form
>
> of lack of purification. That paints one into a corner
> of not understanding the construct at all. Last but
> not least s(CASP) starting with s(ASP),
>
> have also found uses for some forms of forall/2.
> Just read the papers follow the forums and
> inspect the systems. forall/2 has
>
> come to amazing new life. forall is also
> not the worst name of the predicate, since it can
> provide the so called bounded universal quantifier,
>
> under certain circumstances you can tranlate it
> (this is left as an exercise):
>
> ALL(x):[A => B]
>
> But I have recently started calling it Peano
> implication, since Giuseppe Peano used the
> following notation for it:
>
> A =>x B
>
> putting more emphasis on the underlying
> implication than on the universally
> bound variable.
>
> Have Fun!
> Mostowski Collapse schrieb am Mittwoch, 13. Juli 2022 um 01:02:47 UTC+2:
> > Also the uses of forall/2 have increased in the past.
> > Some people use it as a replacement for failure driven loop:
> >
> > ?- G, C, fail; true.
> >
> > They write it as:
> >
> > ?- forall(G, C).
> >
> > It has the advantage/disadvantage that it signals
> > failure of C. Which the failure driven loop does not do.
> > You find it in the wild here:
> >
> > main :-
> > forall(number_fizzbuzz_below_100(_, FizzBuzz),
> > (write(FizzBuzz), write('\n'))).
> >
> > https://github.com/triska/clpz/issues/12
> >
> > Its from some of your users of Scryer Prolog
> > and some of your users of CLP(Z). So I guess
> > you dont know who your users are?
> >
> > Good luck with that…
> > You are Genius like Putin.
> > Mostowski Collapse schrieb am Mittwoch, 13. Juli 2022 um 00:17:00 UTC+2:
> > > Corr.: Currently in Prolog we would have:
> > >
> > > ?- X = 3, findall(X, member(X, [1,4,2]), L).
> > > X = 3,
> > > L = []
> > >
> > > In as far forall/2 has a similar „problem“
> > > which is usually taken care by the programmer,
> > > similarly like the programmer watches
> > >
> > > that his findalls are purified according to the
> > > use case he has. Etc.. etc… But compared
> > > to Lambda Prolog ordinary prolog is
> > >
> > > more primitive and has primafacie some inference
> > > rules missing, although a lot can be compensated by
> > > meta interpreters, little theorem provers, little
> > >
> > > new languages written in Prolog itself. But these little
> > > tools might be impure. Some lamda Prolog through its
> > > HOAS can enforce meta circular purity. Here I
> > >
> > > totally agree that Prolog lacks this feature. But you cannot
> > > add this feature by forbidding things as you do. Compared
> > > to Lamda Prolog your approach of turding Prolog
> > >
> > > by disrupting GitHub with crazy comments and
> > > no contribution has zero impact on improving the
> > > situation. Its just nonsense.
> > > Mostowski Collapse schrieb am Mittwoch, 13. Juli 2022 um 00:01:29 UTC+2:
> > > > In Lambda Prolog you could define a findall
> > > > by accempting a higher order closure using
> > > > some lambda binder, here I am using (\)/2 for
> > > >
> > > > this purpose. findall would only have arity 2:
> > > >
> > > > ?- findall(X\member(X, [1,4,2]), L).
> > > > L = [1, 4, 2]
> > > > ?- X = 3, findall(X\member(X, [1,4,2]), L).
> > > > X = 3,
> > > > L = [1, 4, 2]
> > > > But you have to rethink your logic programming
> > > > language from ground up. You might need a different
> > > > read term, or some post processing of read term.
> > > >
> > > > Lambda Prolog does all that. But posting turds on GitHub
> > > > does nothing. It only shows that you are ignorant about
> > > > possible solutions that exist since Alonzo Church,
> > > >
> > > > https://en.m.wikipedia.org/wiki/Alonzo_Church
> > > >
> > > > The solutions are older than the 50 years of prolog.
> > > > Mostowski Collapse schrieb am Dienstag, 12. Juli 2022 um 23:50:20 UTC+2:
> > > > > Well the error is always the programmer, in this
> > > > > case the programmer doesnt know that in Prolog
> > > > > bound variables have to be „ purified“ i.e. given
> > > > >
> > > > > different names. For example spinning your nonsense
> > > > > further far ahead, you could also demand to ban
> > > > > findall from Prolog, because:
> > > > >
> > > > > ?- findall(X, member(X, [1,4,2], L).
> > > > > L = [1, 4, 2]
> > > > >
> > > > > X is not instantiated in the answer, so by monotonicity,
> > > > > we should be able to instantiate it, but it goes wrong:
> > > > >
> > > > > ?- X = 3, findall(X, member(X, [1,4,2], L).
> > > > > fail
> > > > >
> > > > > Separating away variable names is bread and butter in
> > > > > theorem proving. I dont think double_quotes chars value
> > > > > is a contribution here, neither if_ etc.
> > > > >
> > > > > I dont find any proposal for an improvement either in
> > > > > the new Prolog systems like Trealla, Scryer, etc..
> > > > >
> > > > > I only find turds on GitHub all over the place forbid
> > > > > this forbid that despite there is not a single outcry
> > > > > by other Prolog programmers that variable
> > > > >
> > > > > purification is not a body convesion step in ISO standard
> > > > > Prolog. Write please an amendmend to the ISO standard
> > > > > or define a new language with automatic variable
> > > > >
> > > > > separation and then we can talk again.
> > > > >
> > > > > P.S.: Lambda Prolog can do it. But you would write
> > > > > findall invocation slightly differently.
> > > > > Markus Triska schrieb am Dienstag, 12. Juli 2022 um 19:21:23 UTC+2:
> > > > > > Mostowski Collapse <burs...@gmail.com> writes:
> > > > > >
> > > > > > > Which had these people behind it, potential users of it:
> > > > > > However, not everyone in this list supports everything in the document.
> > > > > > And the document is from 14 years ago: Back then, important constructs
> > > > > > such as if_/3, tfilter/3 etc. were not even found, and the quest for
> > > > > > better constructs was quite stalled. We can do better today than many of
> > > > > > us thought possible in 2008, or even in 2016: For example, just in these
> > > > > > last 6 years, we got 4 new Prolog systems (Scryer, Trealla, Tau and
> > > > > > ichiban/prolog) where double_quotes is set to chars by default. Who
> > > > > > thought that this was possible in 2008? I think even in 2012 or even
> > > > > > later, implementors advocated for JavaScript-style "strings" in Prolog
> > > > > > and even added them to their systems, until a new representation
> > > > > > pioneered by Scryer Prolog made chars viable in newer systems. forall/2
> > > > > > probably likewise seemed necessary in 2008, but does it still seem so
> > > > > > today? A better, not yet found construct, could likewise make it
> > > > > > obsolete, just like JavaScript-style strings have now become obsolete.
> > > > > > > Make a GitHub search, you find many places where it is used
> > > > > > > by some Prolog programmer. Its kind of staple food.
> > > > > > You will find a lot on GitHub, a lot of Java and C code too. It could
> > > > > > make for an interesting analysis, however I find decisions based on such
> > > > > > statistics subject to certain doubts: For example, is a construct that
> > > > > > violates elementary logical properties good because it appears in a lot
> > > > > > of programs? Or does this rather show that many programs could be
> > > > > > improved by removing this construct entirely from the language?
> > > > > >
> > > > > > All the best,
> > > > > > Markus
> > > > > >
> > > > > > --
> > > > > > comp.lang.prolog FAQ: http://www.logic.at/prolog/faq/
> > > > > > The Power of Prolog: https://www.metalevel.at/prolog

Small addendum. In certain situations (\+ A) acts
as ¬A, but in other situations it can also act as
¬∃x1..,∃xnA for some variables x1,..,xn.

Same for forall/2, in certain situations forall(A,B)
acts as A → B, but it can also act as ∀x1..,∀xn(A →
∃y1..∃ymB). So its more complicated than only

forall quantifier, its forall quantifier implication
existential quantifier. But when is it Peano implication?
Well, for example if the second formula, i.e. B is

ground negation, if during execution, from the
bindings after A the currently invoked B is already
ground. The the result of forall/2 is not this:

∀x1..,∀xn(A → ∃y1..∃ymB)

But only this:

∀x1..,∀xn(A → B)

Mostowski Collapse schrieb am Mittwoch, 13. Juli 2022 um 01:32:58 UTC+2:
> Peanos conditional made it
> even into the Principia Mathematica:
>
> Before we look at a wider range of examples, a detailed
> example involving quantified variables will prove to be
> instructive. Whitehead and Russell follow Peano’s
>
> practice of expressing universally quantified conditionals
> (such as “All ps are qs”) with the bound variable
> subscripted under the conditional sign.
>
> https://plato.stanford.edu/entries/pm-notation/#Exam
>
> Lets make Peano great again!

Ciao Prologs “State of the Art” is rather the
night mare of “The Art of loosing State”.

?- assertz(foo).
yes

?- foo.
yes

?- repeat, fail.
{ Execution aborted }

?- foo.
{ERROR: No handle found for thrown exception error(existence_error(procedure,'user:foo'/0),'user:foo'/0)}
aborted

https://ciao-lang.org/playground/

I hope SWI-Prolog will not blindly immitate
every nonsense from Ciao Prolog.

Workers do still synchronously process message
they receive. As a result Ciao cannot send an “abort”
control to a worker, since Ciao Prolog itself inside

the worker is not asyncified. As a result I see one
Worker going down and another Worker comming
up, when I press Abort button in Ciao, and the

dynamic database state is gone. Bye Bye.

BTW: As soon as you have asyncified your Prolog
interpreter, you don't need the single worker anymore.

Mostowski Collapse schrieb am Freitag, 5. August 2022 um 02:58:17 UTC+2:
> Ciao Prologs “State of the Art” is rather the
> night mare of “The Art of loosing State”.
>
> ?- assertz(foo).
> yes
>
> ?- foo.
> yes
>
> ?- repeat, fail.
> { Execution aborted }
>
> ?- foo.
> {ERROR: No handle found for thrown exception error(existence_error(procedure,'user:foo'/0),'user:foo'/0)}
> aborted
>
> https://ciao-lang.org/playground/
>
> I hope SWI-Prolog will not blindly immitate
> every nonsense from Ciao Prolog.

Question was, what means syncify?

It means that you turn your Prolog interpreter into an Engine
that can yield, but that you also have some auto-yielding.
So that the the browser or node.exe can process operating

system tasks while the Prolog system is running. Basically the
JavaScript async/await is an extended iterator code rewriting
of a form of yield, which yields promises. If you take this path

you would also need to extended the engine concept so that
you can voluntarily yield promises, like for example for a fetch.
In such a scenario the Prolog system might appear to block,

this is the other illusion the asyncification can create. Basically
you can create the following illusions by asyncification
without the need of a pre-emptive scheduler:

- Non-blocking parallelism between Prolog system and operating system
- Blocking wait for completion of some operating system tasks

Optionally you can also use it for multiple Prolog threads, but
I don’t see a point in doing this. So I branded this “misuse”.
But you could do this as well and it has certainly some use

cases if the multiple Prolog threads do a lot of operating
system tasks. But it is missing in the above list for the moment,
so conceptionally there are only “two” co-routines the single

threaded Prolog system and the operating system tasks event
loop provided by the browser or node.exe. In the same way its
possible to make a Python variant of such an engine.

Mostowski Collapse schrieb am Freitag, 5. August 2022 um 03:01:16 UTC+2:
> Workers do still synchronously process message
> they receive. As a result Ciao cannot send an “abort”
> control to a worker, since Ciao Prolog itself inside
>
> the worker is not asyncified. As a result I see one
> Worker going down and another Worker comming
> up, when I press Abort button in Ciao, and the
>
> dynamic database state is gone. Bye Bye.
>
> BTW: As soon as you have asyncified your Prolog
> interpreter, you don't need the single worker anymore.
> Mostowski Collapse schrieb am Freitag, 5. August 2022 um 02:58:17 UTC+2:
> > Ciao Prologs “State of the Art” is rather the
> > night mare of “The Art of loosing State”.
> >
> > ?- assertz(foo).
> > yes
> >
> > ?- foo.
> > yes
> >
> > ?- repeat, fail.
> > { Execution aborted }
> >
> > ?- foo.
> > {ERROR: No handle found for thrown exception error(existence_error(procedure,'user:foo'/0),'user:foo'/0)}
> > aborted
> >
> > https://ciao-lang.org/playground/
> >
> > I hope SWI-Prolog will not blindly immitate
> > every nonsense from Ciao Prolog.

It was two questions already, or a different question altogether,
namely asking for WASM as well.

Disclaimer: Oh my, I invented the word “asyncify” spontanously
yesterday. But it has also some meaning in relation to WASM.
My previous portraying is from experience with CheerpJ, Tau-

Prolog and Dogelog, and only CheerpJ has WASM (the recent
version using 64-bit). Maybe for more WASM specific questions
you need to consult other source, I find for example:

https://web.dev/asyncify/

Possibly when the above community is talking about asyncification
it has a total different meaning then what I described. Attention! Attention!

Also CheerpJ comes without auto-yielding. You can add it
yourself, by calling Java Thread.yield(), it was an undocumented
feature of CheerpJ. But in CheerpJ I could not yield promises so

easily, maybe there is an exotic Java API, and then there
is a danger that CheerpJ doesn’t support it, since it is rather
tailord towards bringing some convetional Swing/Standalone

applications to the web, so this is a specific new feature of the
Dogelog engine, breaking out of a particular Java world.

Mostowski Collapse schrieb am Freitag, 5. August 2022 um 10:16:49 UTC+2:
> Question was, what means syncify?
>
> It means that you turn your Prolog interpreter into an Engine
> that can yield, but that you also have some auto-yielding.
> So that the the browser or node.exe can process operating
>
> system tasks while the Prolog system is running. Basically the
> JavaScript async/await is an extended iterator code rewriting
> of a form of yield, which yields promises. If you take this path
>
> you would also need to extended the engine concept so that
> you can voluntarily yield promises, like for example for a fetch.
> In such a scenario the Prolog system might appear to block,
>
> this is the other illusion the asyncification can create. Basically
> you can create the following illusions by asyncification
> without the need of a pre-emptive scheduler:
>
> - Non-blocking parallelism between Prolog system and operating system
> - Blocking wait for completion of some operating system tasks
>
> Optionally you can also use it for multiple Prolog threads, but
> I don’t see a point in doing this. So I branded this “misuse”.
> But you could do this as well and it has certainly some use
>
> cases if the multiple Prolog threads do a lot of operating
> system tasks. But it is missing in the above list for the moment,
> so conceptionally there are only “two” co-routines the single
>
> threaded Prolog system and the operating system tasks event
> loop provided by the browser or node.exe. In the same way its
> possible to make a Python variant of such an engine.
> Mostowski Collapse schrieb am Freitag, 5. August 2022 um 03:01:16 UTC+2:
> > Workers do still synchronously process message
> > they receive. As a result Ciao cannot send an “abort”
> > control to a worker, since Ciao Prolog itself inside
> >
> > the worker is not asyncified. As a result I see one
> > Worker going down and another Worker comming
> > up, when I press Abort button in Ciao, and the
> >
> > dynamic database state is gone. Bye Bye.
> >
> > BTW: As soon as you have asyncified your Prolog
> > interpreter, you don't need the single worker anymore.
> > Mostowski Collapse schrieb am Freitag, 5. August 2022 um 02:58:17 UTC+2:
> > > Ciao Prologs “State of the Art” is rather the
> > > night mare of “The Art of loosing State”.
> > >
> > > ?- assertz(foo).
> > > yes
> > >
> > > ?- foo.
> > > yes
> > >
> > > ?- repeat, fail.
> > > { Execution aborted }
> > >
> > > ?- foo.
> > > {ERROR: No handle found for thrown exception error(existence_error(procedure,'user:foo'/0),'user:foo'/0)}
> > > aborted
> > >
> > > https://ciao-lang.org/playground/
> > >
> > > I hope SWI-Prolog will not blindly immitate
> > > every nonsense from Ciao Prolog.