🚀 go-pugleaf

In article <11522@cup.portal.com> dan-hankins@cup.portal.com (Daniel B Hankins) writes:
>This is the tricky one.  This is the one that makes me think that perhaps
>a tree, or even a digraph, is not the proper way to think about classifying
>objects.
>
>What is the proper way?  I'll let you know when and if I figure it out.

The real world is full of all kinds of arbitrary relationships.
If you want to directly model the real world, you will have to
allow arbitrary relations in your language, ie. an arbitrary graph.

The object oriented approach seems to be "the real world is too complicated;
lets fix it (force it into a tree) and then model it".
This works fine when the problem you are trying to model fits
your inheritance tree naturally, but when the fit is unnatural, you
have given the programmer some more work.

An approach which seems to offer more promise of modelling the real world
directly is parametric polymorphism.  Algorithms rather than objects
specify what other algorithms they require to operate.  Universal
and existential quantifiers can be used in the type specification of
algorithms to make algorithms more reusable.  For example, here
is the type specification for "sort", which can sort arrays of any type:

	sort: [ forall t: type,
			forall i: int,
			forall j: int,
			exists >: [t,t] bool,
			       a: [i..j] array t
		  ] proc void;

This says "sort" operates on arrays of any type and any number of elements,
so long as the function ">" is defined between the elements.

This is a simplified example; a general sort would not require the
data structure to be an array.  Sorting linked lists may be equally
desirable, and requires sort to be further generalized to require
that swap (or := and a temporary constructor) exist.
--------
Andrew K. Wright      akwright@watmath.waterloo.edu
CS Dept., University of Waterloo, Ont., Canada.