> Consider
>
> type a = A of int * int
> | B of (int * int)
>
> The result of A (3, 4) will be a two element tuple type
tagged
> appropriately for 'A' (in this case 0).
>
> The result of B (3, 4) will be a one element tuple type
tagged for B,
> with the single element referring to the two element tuple containing
(3,
> 4).
>
> Because tuples are generally immutable, there is little semantic
> difference, but the compiler does have to keep track of which is which.
In
> most cases I would guess that 'A' would be more efficient (unless
there are
> lots of larger constructors sharing the same tuple).
Is there a similar way as 'A' above for records?
This isn't valid Ocaml:
type a = A of {mutable xA: int; mutable yA: int}
| B of xyB
and xyB = {mutable xB: int; mutable yB: int}
Background: I had a case (a search tree data strucuture)
where
the additional indirection results in a 30% runtime
penalty,
due to increased pointer chasing (cache misses). It
is the
way it is in Ocaml and probably hard to change, but
I would
like to understand if there are fundamental reasons
for it to
be necessary or not. See also:
http://caml.inria.fr/pub/ml-archives/caml-list/2005/11/9a6dcbcb4f3b4c0ebe9cdf28ac3d289b.en.html
Sebastian.