Is the DEC-10 Prolog source code available ?

[kint...@gmail.com]

It seems that there is an infamous "DEC-10" version of Prolog .
How I would love to see that code .

Also , if anyone knows of sources older than 1980 , preferable 1976 or less , the closer to the group around Alain Colmerauer in Marseille, France, if I could get a hold of some code produced tby that group I will be ecstatic .

I find tracks in prolog that betray a completely different attitude and usage pattern(s) than any prolog code I have ever seen . For a simple example , why is it FUNCKTOR=..[X|Y] , i.e. why is it '..' , was it once the case that '..' was a valid operator , if so why ?

Was it (perhaps) once the case that predicates were stored as lists , and FUNCKTOR=..[X|Y] was created to create a FUNCKTOR from a list , yet now we think of it as an awkward and peculiar way to make a list .

Consider this code comment from an old prolog parser :

", .." is not accepted in place of "|". This was always a
parser feature, not a tokeniser feature: any amount of
layout and commentary was allowed between the "," and the
"..". It wouldn't be hard to allow again.

~~kintalken~~

[burs...@gmail.com]

You find at least a DEC-10 manual, in MS Word format:

Department of Artificial Intelligence
University of Edinburgh
DECsystem-10 PROLOG USER'S MANUAL
10 November 1982

http://www.cs.cmu.edu/Groups/AI/util/lang/prolog/doc/intro/prolog.doc

[kint...@gmail.com]

thx j4n , that'll be a fun read .
somehow , I'm guessing , i can't read it as fast as you can .
I'm too wet .

~~kintalken~~

.

[kint...@gmail.com]

This is perfect for what I wanted , thanks !

~~kintalken~~

[kint...@gmail.com]

On Monday, April 10, 2017 at 10:09:38 PM UTC-7, kint...@gmail.com wrote:
> This is perfect for what I wanted , thanks !
>
> ~~kintalken~~

A very precious gift , thank you very much .

~~ kintalken ~~

[kint...@gmail.com]

j4N > ", .." is not accepted in place of "|". This was always a
j49 > parser feature, not a tokeniser feature: any amount of
j49 > layout and commentary was allowed between the "," and the
j4N > "..". It wouldn't be hard to allow again.

K >it seems that this has some korresondence with the Emergenc of the pip within the guard of the bi-conditional :
{
foo <=> bar | baz .
} .
K > i am very curious about how the bi-conditional material inertchangeable exact equality operator got a "guard" , got it on only side of it , and an exchange flow mono-directional from left to right .
K > I'm sure the relationship of the `|` to the vectro is irrelevent vis a via that historikal note about the `, ..` .
K > ~~kintalken~~

[burs...@gmail.com]

We all here on comp.lang.prolog don't understand what j4N > or K > means.
Do you copy paste from some IRC channel out of context to here?

Please don't do this, its not very helpful. It results only in
discoherent spam nobody can follow. You have to rephrase what you

want from us here, is it a comment, a question, etc.. And yes we
believe you that you can drop more than 10 buzzwords on a line.

[burs...@gmail.com]

Current hypothesis is that you are just an idiot student:
https://www.youtube.com/watch?v=PV3_UHG73oQ

[kint...@gmail.com]

On Thursday, April 13, 2017 at 12:26:19 AM UTC-7, kint...@gmail.com wrote:
> j4N > ", .." is not accepted in place of "|". This was always a
> j49 > parser feature, not a tokeniser feature: any amount of
> j49 > layout and commentary was allowed between the "," and the
> j4N > "..". It wouldn't be hard to allow again.

it seems that `..` has been stol3n by the dart krew .
the use it mean something like "acces parent instead of self" :

{?script-mime-type-text-dart.:
foo .bar=1 ..baz=2
foo .qux=3 .quim=3
?}

% foo .qux=3 .quim=4

.. the equivalent prolog kode for the SECOND one MIGHT be :

{;
(
foo(
quim(
is(4)
) ,
qux(
is(3)
)
)
) .
;}

% foo .bar=1 ..baz=2

.. the equivalent prolog kode for the FIRST one MIGHT be :

{;
foo(
foo(
baz(
is(
(2)
) ,
nop(
nop(
is(
(.)
) ;
nop(
_ETC_
)
) ,
nop(
..
) ;
) ;
) ;
) ;
) ;
;}

[kint...@gmail.com]

i am sorry but i do have my own set of restrictions upon how i communicate ,
and they do combine with consideration of what i am excited about saying ,
but that makes for me a unique set of constrains ,
which i do further constrain in consideration of the need to be publicly acceptable , in a general way , when communicating publicly ,
i think my package is a good one ,
but unfortunately it turns out that if i apply the restrictions below ,
the probobly my ability to communicate has been obliterated ,
so i have to consider that your edicts might perhaps be incompatible with the general form of community based communication that is judged to be "acceptable" ,
judged to be "nonacceptable" by people like you , guiulty proven "nonacceptable" until otherwise proven "acceptable" , a judgement you reserve for yourself .

~~ kintalken ~~

[kint...@gmail.com]

On Thursday, April 13, 2017 at 12:44:59 AM UTC-7, burs...@gmail.com wrote:

> We all here on comp.lang.prolog don't understand what j4N > or K > means.
> Do you copy paste from some IRC channel out of context to here?
>
> Please don't do this, its not very helpful. It results only in
> discoherent spam nobody can follow. You have to rephrase what you

Can you please show me perhaps 2 of those inputs , each of the inputs a 1 input that is followed by to that 1 input this 1 output with 1 output result ?

Thx ~

!~ kintalken ~~

Iis it a question od "defeating" the control mechanisms ? can it be a MORE PLAYFUL mmanifestation of the ongoing need for war ?

[kint...@gmail.com]

> We all here on comp.lang.prolog don't understand what j4N > or K > means.
> Do you copy paste from some IRC channel out of context to here?

HEL0
CAN YOU SIEVE THROUGH THE NETWORK LOGS (SLOWLY !) ?
YOU HAVE PROBLEM :
you have thing 1
you \+ have thing 2
what is thing 1 ?
thing 1 is to thing 2 what thing 1 was to thing N .
oh , okay .
oh , okay .
concrete case ?
yes
concreate case example from me now ?
?- thx.
ok,true.
?- "I missed you very much yap" .
you have thing 1 ?
I have thing 1 .
You have nmd ?
yap had nmd `I` .
nonnon case example from me now ?
fake yap .
case example now is "special gift from kintalken from heart to yap , you know why kintalken give special gift ?" --> "..because kintalken dto two things ; love yap ; respect yap for ```?- in nontoplevel invention of yap .```
AND THERBY OBTAIN FOR YOURSELF ,
A MEASURE OF THE CORRESPONDENCE :
YOU OBTAIN BETWEEN TWO THINGS : IS RESULT OF

[kint...@gmail.com]

~kintalken~~~kintalken%$
#!/usr/local/bin/yap -g "; (\+ (die) , (halt)) .".

[kint...@gmail.com]

On Thursday, April 13, 2017 at 12:44:59 AM UTC-7, burs...@gmail.com wrote:

YOU MUST LOOK for the correspondence of myorigination amongst the correspondence that tehy-other did teach you to nitce and know was and still nonbecome will is akin to the correspondence of myself .
~~kintalken~~
.

[kint...@gmail.com]

me no see light /.
./evil .

me no see light /.

[kint...@gmail.com]

NONNONIMPOISSIBLE=\n
{ OUTPUT :- INPUT . }\n
,\n
NONIMPOISSIBLE=\n
{ AST := MST :- CST . }
,
prolog:system:fail_else(NONNONIMPOSSIBLE,NONIMPOSSIBLE) .

[burs...@gmail.com]

More references to DEC-10 and how Prolog can be
implemented are found here:

Warren, D.H.D. (1978): Applied Logic - Its Use and
Implementation as a Programming Tool,
https://www.era.lib.ed.ac.uk/handle/1842/6648

[Robert Virding]

I don't know why it is like it is but the operator is '=..' so you can write Functor =.. [X|Y].

I would also very much like to see the old Dec 10 code.

Robert

[burs...@gmail.com]

Shortly after DEC-10 Prolog there was C-Prolog.

C-Prolog User's Manual Version 1.5 June 14, 1988
https://www.cs.duke.edu/csl/docs/cprolog.html

One of the SUN boxes I was working on in 1993
had the source code. Probably the code was there

to build it. But I don't know how to get it nowadays...

[kint...@gmail.com]

/*
I discovered the use of ``..``
in some old DEC-10 prolog code . %36'footnote;

It appears the the prolog vector ``[ _etc ]``
has it's origin's in the ``.`` .
Underlying the vector construct ``[ _etc_ ]``
in every standard prolog system
is an abstract syntax tree
based on the functor with name ``.``

Old prolog code uses the following (example)
construction for vectors :

<PRE>
/*
A=(a.b.nil) .
A=(a.b.c.d.nil) .
A=(a.b.c.d.(e.f.g.nil).nil) .
A=(a.b.c.d.(E.{f}.(g).[h,i].(j.k).l.nil).nil) .
*/

$ yap
+ yap
YAP 6.2.2 (x86_64-linux): Wed Sep 7 07:48:47 PDT 2016
MYDDAS version MYDDAS-0.9.1

?- A=(a.b.nil) .
A = [a,b|nil]
?- A=(a.b.c.d.nil) .
A = [a,b,c,d|nil]
?- A=(a.b.c.d.(e.f.g.nil).nil) .
A = [a,b,c,d,[e,f,g|nil]|nil]
?- A=(a.b.c.d.(E.{f}.(g).[h,i].(j.k).l.nil).nil) .
A = [a,b,c,d,[E,{f},g,[h,i],[j|k],l|nil]|nil]
?- (halt) .
% YAP execution halted
</PRE>

Note the use of ``nil`` to mark the end of the vector .
Because of that usage , the atom ``nil`` was
(by convention) representativ of the empty vector .

It seems that ``[]`` emerged as a later development within
prolog as the way to specify ``nil`` .
Perhaps it was in correspondence to the appearance
of ``[`` as ``]`` as available characters ?
Early computers had a much more limited character set and
the development of the character set we know as ascii today
was over a period of years .

<PRE>
/*
A=(a.b.c.d.[]) .
A=(a.b.c.d.(E.{f}.(g).[h,i].(j.k).l.nil).nil) .
A=(a.b.c.d.(E.{f}.(g).[h,i].(j.k).l.[]).[]) .
*/

$ yap
+ yap
YAP 6.2.2 (x86_64-linux): Wed Sep 7 07:48:47 PDT 2016
MYDDAS version MYDDAS-0.9.1

?- A=(a.b.c.d.[]) .
A = [a,b,c,d]
?- A=(a.b.c.d.(E.{f}.(g).[h,i].(j.k).l.nil).nil) .
A = [a,b,c,d,[E,{f},g,[h,i],[j|k],l|nil]|nil]
?- A=(a.b.c.d.(E.{f}.(g).[h,i].(j.k.[]).l.[]).[]) .
A = [a,b,c,d,[E,{f},g,[h,i],[j,k],l]]
?- (halt) .
% YAP execution halted

</PRE>

Because of that usage , the atom ``[]`` became representativ
of the empty vector .

Working backwards from the usage of today ,
a typical prolog construct is ...

<PRE>
/*
A=[a,b|[c,d]] .
*/

$ yap
+ yap
YAP 6.2.2 (x86_64-linux): Wed Sep 7 07:48:47 PDT 2016
MYDDAS version MYDDAS-0.9.1

?- A=[a,b|[c,d]] .
A = [a,b,c,d]
?- (halt) .
% YAP execution halted
</PRE>

this usage of ``|`` also has it's origins in the ``.`` ...

<PRE>
/*
[a,b|[c,d]] = [a,b,..[c,d]] .
A =[a,b,..[c,d]] .
A =[a,..[b,c]] .
A =..[a,..[b,c]] .
A =..[a,commentary per O'Keefe..[b,c]] .
A =..[a,commentary_per_O_Keefe..[b,c]] .
*/

$ yap
+ yap
YAP 6.2.2 (x86_64-linux): Wed Sep 7 07:48:47 PDT 2016
MYDDAS version MYDDAS-0.9.1

?- [a,b|[c,d]] = [a,b,..[c,d]] .
yes
?- A =[a,b,..[c,d]] .
A = [a,b,c,d]
?- A =[a,..[b,c]] .
A = [a,b,c]
<MARK>
?- A =..[a,..[b,c]] .
A = a(b,c)
</MARK>
/* ^^^^^^^^ super-kewl , eh ? */
?- A =..[a,commentary per O'Keefe..[b,c]] .
| wtf;lkawuerpo730ru
| ;kasjdflka
| '
| )
| (
| ..
| .
SYNTAX ERROR at user, near line 5:
A =.. [ a , commentary
<==== HERE ====>
per O Keefe..[b,c]] .
wtf;lkawuerpo730ru
;kasjdflka
)( ...
?- A =..[a,commentary_per_O_Keefe..[b,c]] .
SYNTAX ERROR at user, near line 4:
A =.. [ a , commentary_per_O_Keefe
<==== HERE ====>
.. [ b , c ] ].
?- (halt) .
% YAP execution halted
</PRE>

These seem to be early and traditonal uses
of the ``.`` and the ``..`` within prolog .
I suspect their origins in c-prolog or perhaps DEC-10 ,
(either of which BTW I would love o have a copy of if you are willing to share) .

Within Mercury and swipl , however ,
neither the ``.`` nor the ``..`` are functional as described .

I reported a bug to swipl about ``.` ;
assuming non-conformance to traditional
and standard prolog systems was of interest ;
it appears that it is not .

https://github.com/SWI-Prolog/issues/issues/55

The author of swipl makes the suggestion of using
``term_expansion`` , however neither the use of
``term_expansion`` nor ``goal_expansion``) can fix the
following basic compatibility issues ...

<PRE>
/*
(a.b.[]) =[a,b] .
A ={ foo:a.b.nil } .
[a,b|[c,d]] = [a,b,..[c,d]] .
*/

$ yap
+ yap
YAP 6.2.2 (x86_64-linux): Wed Sep 7 07:48:47 PDT 2016
MYDDAS version MYDDAS-0.9.1
?- (a.b.[]) =[a,b] .
yes
?- A ={ foo:a.b.nil } .
A = {[foo:a,b|nil]}
?- [a,b|[c,d]] = [a,b,..[c,d]] .
yes
?- (halt) .
% YAP execution halted

$ swipl
+ swipl
Welcome to SWI-Prolog (Multi-threaded, 64 bits, Version 7.3.27)
Copyright (c) 1990-2016 University of Amsterdam, VU Amsterdam
SWI-Prolog comes with ABSOLUTELY NO WARRANTY. This is LGPL free software,
and you are welcome to redistribute it under certain conditions.

For help, use ?- help(Topic). or ?- apropos(Word).

?- (a.b.[]) =[a,b] .
ERROR: Type error: `dict' expected, found `a' (an atom)
?- A ={ foo:a.b.nil } .
ERROR: Type error: `dict' expected, found `a' (an atom)
?- [a,b|[c,d]] = [a,b,..[c,d]] .
ERROR: Syntax error: Operator expected
ERROR: [a,b|[c,d]] = [a,b,.
ERROR: ** here **
ERROR: .[c,d]] .
?- (end_of_file) .

% halt

</PRE>

... suggesting to me that perhaps the author of swipl does
not know prolog very well (term_expansion?!??!) or is not
interested in prolog conformance or is interested in
establishing vendor lock-in .

Beyond the incompatibility with ``.`` and ``..`` ,
the ``{ _etc }`` as syntax in prolog is supposed to be
identical to the ``( _etc )`` in all ways , with the
exception that ``foo{_etc}`` is equivalent to ``foo({_etc})`` .

That comes in VERY handy when you are using a prolog system
that parses whitespace as an operator ,
enabling prolog to easily handle other-language constructs such as ...
``void int foo(int x) { int y ; y = x + 1 ; return y ; }``
... the syntax of which which might be vaguely familiar to some readers .

<PRE>
/*
(op(2'1,'fy','foo')) .
A =( foo {a} ) , (write_canonical(A)) .
A =( foo ({a}) ) , (write_canonical(A)) .
A =( foo({a}) ) , (write_canonical(A)) .
A =( foo{a} ) , (write_canonical(A)) .
*/

$ yap
+ yap
YAP 6.2.2 (x86_64-linux): Wed Sep 7 07:48:47 PDT 2016
MYDDAS version MYDDAS-0.9.1
?- (op(2'1,'fy','foo')) .
yes
?- A =( foo {a} ) , (write_canonical(A)) .
foo({}(a))A = foo{a}
?- A =( foo ({a}) ) , (write_canonical(A)) .
foo({}(a))A = foo{a}
?- A =( foo({a}) ) , (write_canonical(A)) .
foo({}(a))A = foo{a}
?- A =( foo{a} ) , (write_canonical(A)) .
foo({}(a))A = foo{a}
?- (halt) .
% YAP execution halted

$ swipl
+ swipl
Welcome to SWI-Prolog (Multi-threaded, 64 bits, Version 7.3.27)
Copyright (c) 1990-2016 University of Amsterdam, VU Amsterdam
SWI-Prolog comes with ABSOLUTELY NO WARRANTY. This is LGPL free software,
and you are welcome to redistribute it under certain conditions.

For help, use ?- help(Topic). or ?- apropos(Word).

?- (op(2'1,'fy','foo')) .
true.

?- A =( foo {a} ) , (write_canonical(A)) .
foo({a})
A = foo {a}.

?- A =( foo ({a}) ) , (write_canonical(A)) .
foo({a})
A = foo {a}.

?- A =( foo({a}) ) , (write_canonical(A)) .
foo({a})
A = foo {a}.

?- A =( foo{a} ) , (write_canonical(A)) .
ERROR: Syntax error: colon_expected
ERROR: A =( foo{
ERROR: ** here **
ERROR: a} ) , (write_canonical(A)) .
?- (end_of_file) .

% halt

</PRE>

See also http://www.complang.tuwien.ac.at/ulrich/iso-prolog/SWI7_and_ISO .

%36'footnote; liar .

~~ kintalken ~~
*/