🚀 go-pugleaf

>>		Because compromise between flexibility and safety
>>		will always involve a trade-off, I believe that
>>		untyped functional languages (e.g. those in the
>>		LISP/Scheme style) will never become completely obsolete.

In article <2215@opal.cs.tu-berlin.de> wg@opal.cs.tu-berlin.de writes:
>Wolfgang Grieskamp 
>	There is no meaningful expression which has no type.
>	In the case of lists consisting of values of different type,
>	functions must exist defined over all instances
>	of the "untyped" list in a given program to give meaning to the list.
>	Thus the values of the list must have some common property (a type).
>	In the very rare case, this property is to be just an object ... 
	       ^^^^^^^^^

If you remove the imperative features from the core of Common Lisp,
and remove the features which allow function definitions
to be disassembled as lists, what remains _can_ be viewed
as a functional language in which all expressions
denote elements of the recursive domain

	D = (Atoms + Booleans + DxD + D->D)_bottom.

It is "untyped" in the sense that all expressions
denote objects of the same type -- domain D.
You can create lists of arbitrary elements,
and define functions which take and return arbitrary elements
(even copies of the function itself).
So it is not so rare actually to require only
the property of being an object!

I use just such a language as the basis for my work
in functional/logic integration.

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