🚀 go-pugleaf

>]		_Bottom_ is NOT synonymous with nontermination!!!!
>]		We are dealing with a DECLARATIVE paradigm,
>]		and nontermination is an _operational_ concept.

David Gudeman:		gudeman@cs.arizona.edu <23552@megaron.cs.arizona.edu>
>	Well, I'd have to say that bottom _is_ synonymous
>	with nontermination if the only programs
>	that are defined to represent bottom
>	are those whose evaluation will never terminate.
>	This is the case in the lambda calculus, for example.

Some nonterminating programs in the lambda calculus
do NOT denote bottom (e.g. the fixpoint operator).
The language of denotational semantics
is a much more realistic basis for functional programming
than the pure untyped lambda calculus.
Who wants to program in a language that has no concrete data-types?
In the area of denotational semantics,
you can make any primitive function produce bottom
for certain inputs, so long as everything
is monotonic and continuous.

>	It might be a good idea _not_ to limit the idea of bottom
>	and let it include more general undefined operations
>	such as out-of-range references and whatever peculiar
>	things might result from that.  In this case, it would be
>	allowable for some program optimizations to change
>	an error result into bottom.  For example,
>	an optimization that removes bounds checking from array
>	references might be allowed even though it has the potential
>	of changing an error result into practically anything.

Or vice-versa.  Though we cannot solve the halting problem,
you _might_ want to build into a students' compiler
routines to catch the most obvious form of infinite looping,
and replace the bad subcomputation with the bottom symbol.
Must the result be considered as a different language,
just because the interpreter is _sometimes_ able to tell you
that the program denotes bottom, instead of just letting it loop?
True, there is some extra metalogical information provided,
but as long as the program is forbidden to make use of it,
it need not be considered a change in the language.

	Frank Silbermann	fs@rex.cs.tulane.edu
	Tulane University	New Orleans, Louisianna  USA

In article <3936@rex.cs.tulane.edu> fs@rex.cs.tulane.edu (Frank Silbermann)
writes:
>Maximal information should not be confused with metalogical information.

In article <3940@rex.cs.tulane.edu> fs@rex.cs.tulane.edu (Frank Silbermann)
writes:
>Or vice-versa.  Though we cannot solve the halting problem,
>you _might_ want to build into a students' compiler
>routines to catch the most obvious form of infinite looping,
>and replace the bad subcomputation with the bottom symbol.

This is clearly a useful feature to have.

>Must the result be considered as a different language,
>just because the interpreter is _sometimes_ able to tell you
>that the program denotes bottom, instead of just letting it loop?
>True, there is some extra metalogical information provided,
>but as long as the program is forbidden to make use of it,
>it need not be considered a change in the language.

I agree that if the interpreter has all this extra information, but it's not
available to user programs, then it's not part of the language.  My question
is, why would you want to do this?

Suppose in the language i write a nifty windowing system including an
interactive debugger with flashy graphics, sophisticated tracing, source-level
debugging, the works.  I'm debugging a program which gets into a detectable
infinite loop.  The run-time system detects this, spits out a nasty error
message in Chinese on the line printer down the hall, and my computer ceases to
work henceforth.  A lot of good that does me.

You've got the information, so put it in the language.  You get a new language,
which is isomorphic to the old one if you don't use the new features.  I don't
see what's wrong with that.