Path: utzoo!mnetor!uunet!husc6!tut.cis.ohio-state.edu!mailrus!ames!sri-spam!sri-unix!quintus!ok
From: ok@quintus.UUCP (Richard A. O'Keefe)
Newsgroups: comp.lang.prolog
Subject: Re: behavior of read/get0 at end_of_file
Message-ID: <830@cresswell.quintus.UUCP>
Date: 28 Mar 88 09:38:43 GMT
References: <608> <1197@kulcs.kulcs.uucp> <783@cresswell.quintus.UUCP> <243@gould.doc.ic.ac.uk>
Organization: Quintus Computer Systems, Mountain View, CA
Lines: 85
Keywords: get0 read end_of_file

In article <243@gould.doc.ic.ac.uk>, cdsm@ivax.doc.ic.ac.uk (Chris Moss) writes:
> I have yet to
> find the document that Richard referred to (a few days ago) when he
> claimed that the BSI's mandate was to standardize Edinburgh Prolog.
> It certainly hasn't been repeated in all the other formal
> presentations that have been made to BSI or ISO.

Don't bother, I'm about to post it.

> But if one has to
> follow every wrinkle of an implementation just because it represents
> (arguably) the most popular dialect, then why don't we just
> appoint IBM to write all our standards for us (or Quintus or ...)?
> [And who is the TRUE inheritor of the title "Edinburgh Prolog" anyway? Is
> it the commercial product (formerly NIP) now being sold under that title?]

No, one doesn't have to follow every wrinkle of an implementation.
How often do I have to repeat it?  I don't give a continental for
implementors or implementations.  Not Quintus, not ALS, not Arity, not
IBM, not Borland, not any of them.

	+---------------------------------------+
	|  What I care about is Prolog *USERS*  |
	+---------------------------------------+

The question to be asked every time is "might this change break a reasonable
program?"  "How can we make it easy for people who are already using Prolog
to change over to the standard, especially for people using Prolog systems
whose vendors have made some attempt at compatibility?"

What is "Edinburgh Prolog"?  I have two definitions, which have much the
same practical effect.
(1) An "Edinburgh Prolog" is one whose implementors made a serious and
    reasonably successful attempt to make their system compatible with
    Clocksin & Mellish, or better yet, with DEC-10 Prolog or C Prolog.

(2) An "Edinburgh Prolog" is one to which I can port the DEC-10 Prolog
    library in two days, with only a text editor to help me.  (That is,
    no boot-strapping through Prolog or Lisp.)

By either definition, we have the following results:
	Dialect		is "Edinburgh Prolog"?
	VM/PROLOG	no
	Waterloo Prolog	no
	AAIS Prolog	not quite, but closer than BSI Prolog by (2)-estimated
	BIM Prolog	in "native" mode, no, in "-c" mode almost
	IF Prolog	yes
	Arity Prolog	yes
	ESI Prolog-2	no
	micro-PROLOG	no
	Stony Brook	yes
	SICStus Prolog	yes
	ALS Prolog	yes
	NU Prolog	yes
	Poplog		yes (well, it was in mid-1984)
	LM Prolog	no
	NIP		yes (in 1985)
Other Prolog versions are omitted because I haven't got access to manuals
for them and haven't used them.  The fact that I classify something as
"not an Edinburgh Prolog" does not mean that I regard it as technically
inferior, only that I regard it as sufficiently different to be hard to
port to or from.

> Now in the days before tail recursion and all the other optimizations
> this was inevitable. But why should we encourage this approach today?

A very simple reason:  there are still people trying to use Prolog on
IBM PCs and clones, and several PC Prologs have 64kbyte stacks.  So
failure-driven loops are still necessary on those machines, not because
the Prolog systems are bad, but because they are good enough for the
limitations of the machine to be encountered.

> I seem to get by perfectly well by setting "ignoreeof" in my cshell!

This doesn't work terribly well if you are using the Bourne shell.
Is Prolog to be standardised only for people who use the C shell?

> Now where do I find the Emacs macro for commenting out all lines
> between dot and mark (and removing such comments)?

Well, the editor which I claimed does it isn't Emacs.  Commenting out lines
using "%" is 18 lines of C.  Commenting out the region with /**/ and undoing
that come to 40 lines of C.  I'll send this by E-mail if you're interested:
it should be easy to translate them to mock-Lisp, except that I strongly
dislike mock-Lisp.