🚀 go-pugleaf

butrfeld@swift.cs.tcd.ie writes:

>Can anyone explain the following aspect of the Miranda and Haskell type
>systems that I find annoying ? Is there a theoretical reason for it ?
>
>pairs, triples, quintuples, etc.. are _distinct_ types. In particular,
>(a,(b,c)) != ((a,b),c) != (a,b,c).

A practical reason is to give the implementation freedom to implement
triples etc. as efficiently as possible. Requiring (a,b,c) to be stored
in the same manner as (a,(b,c)) might require an extra level of indirection
(and type equivalence usually implies storage equivalence).

Theoretically I see no reason why (a,b,c) should be required to be
equal to say (a,(b,c)). That seems like implementation details to me.
It's also very assymetric - you have to require either left-pairing
or right-pairing, and there is no obvious reason to prefer one over the
other. It makes perfect sense to me that (a,b,c) is quite simply not a
pair!

-- 
Fergus Henderson             fjh@munta.cs.mu.OZ.AU      
This .signature virus is a self-referential statement that is true - but 
you will only be able to consistently believe it if you copy it to your own
.signature file!

Andrew Butterfield writes:

>Can anyone explain the following aspect of the Miranda and Haskell type
>systems that I find annoying ? Is there a theoretical reason for it ?

>pairs, triples, quintuples, etc.. are _distinct_ types. In particular,
>(a,(b,c)) != ((a,b),c) != (a,b,c).

Fergus James HENDERSON replies:

>Theoretically I see no reason why (a,b,c) should be required to be
>equal to say (a,(b,c)). That seems like implementation details to me.
>It's also very assymetric - you have to require either left-pairing
>or right-pairing, and there is no obvious reason to prefer one over the
>other. It makes perfect sense to me that (a,b,c) is quite simply not a
>pair!

Of course, it is also impossible to let ((a,b),c) = (a,(b,c)), unless
you want to end up having a nondeterministic language. For if a
function expecting a pair were applied to such a thing, you would never
know whether to match its argument with ((a,b),c) or (a,(b,c)).

                                                               Vincent.

In article <1992Aug26.141437.8465@swift.cs.tcd.ie> butrfeld@swift.cs.tcd.ie writes:

> In a language called Sticks&Stones, based loosely on ML, that I have
> used, the following equality always held:

> (a,(b,c)) = (a,b,c)

> In other words a triple is simply a pair whose second item is a pair.
> Note that ((a,b),c) is not a triple.

It sounds like that language didn't allow triples at all, only pairs.
It's certainly possible to do that, but that would certainly be less
convenient in other ways.

For example, in ML a pair is a special case of a more general record
type that consists of name-value pairs known and checked at compile
time.  A pair is just a record whose components are named 1 and 2;
a triple is a record with components named 1, 2, and 3, and so on.
I don't see how to allow pairs and not triples with that kind of
unified design, and that unification is truly elegant and makes
all sorts of other things easier to understand.
-- 
				--Andrew Koenig
				  ark@europa.att.com