🚀 go-pugleaf

In article <1975@m1.cs.man.ac.uk> jk@cs.man.ac.uk (John Kewley ICL) writes:
>
>	In fact, a Hope+ -> DACTL compiler has been written
>	which could produce either lazy or (eager?)
>	DACTL (Is a language with lazy constructors
>	and strict functions eager, strict, semi-lazy, semi-strict?).

I understand what it means to say that a _function_ is strict:
it maps the bottom element of the input domain
to the bottom element of the output domain.
I also understand that this property can justify
evaluation orders which otherwise might not always work.

But how can one speak of strict or lazy constructors?
Consider for example, the ordered pair constructor,
which uses elements X1 and X2 of domains D1 and D2,
to create the element <X1,X2> of domain D1xD2.
The standard selector functions will choose
the appropriate piece of <X1,X2> regardless
of whether the other side happens to be the bottom.

Of course, the language designer may choose to deny the programmer
direct access to the standard selector functions,
and instead provide selector functions which,
before selecting an element, verify that both sides
are strictly above bottom.  In any case,
the elements <X1,bot>, <bot,X2> and <bot,bot> are
distinct elements of D1xD2, regardless of whether
any particular language lets the programmer make use of this fact.

So, when we speak of strict constructors, are we not _really_
describing a property of the _selector_ functions, and not the constructor?
Or, is there another version of domain theory I am not aware of?

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