🚀 go-pugleaf

> As someone who hasn't yet completely converted to the object oriented religion,
> this has always struck me as using the wrong tool for the job.  I really don't
> want a "list of T or subtype of T".  I want a "list of objects that understand
> foo".  Once I take that view, I have no problems, at least in the few
> statically typed languages that allow this (e.g. Russell, and probably FX from
> MIT, and probably Scratchpad II from IBM).  I also don't need to construct
> my types in such a way that all types that understand foo are "derived" from
> a common supertype;  I can use inheritance purely where it simplifies the
> implementation.  And I get full static checking, though elements of the list
> will, of course, somehow carry the "foo" function with them.  (In Russell, I
> would build a list of pairs <x: T, T: [algebra containing foo]>.)


This sounds good.  However, I suspect that these languages don't (didn't?)
have inheritance at all...?  Plus, some people don't like functional languages.
Could you post some pointers to the relevant literature?

Thanks,

-Urs

------------------------------------------------------------------------------
Urs Hoelzle                 			       hoelzle@cs.stanford.EDU
Center for Integrated Systems, CIS 42, Stanford University, Stanford, CA 94305