Type evolution during construction

In a language with inheritance, the evolution of type during construction (and devolution during deconstruction, if appropriate) is a bit tricky. I was recently asked for pointers to papers or references on this, and came up dry on a Google search.

Can anyone suggest papers or references addressing this issue?

Programming with alternatives

I've come up with a new concept, called 'alternative programs', where expressions can have multiple alternatives. I wonder if there are any papers out there that discuss a similar concept. I'm having trouble defining the concept, but here is a try:

Every expression takes the form of a sequence of alternative expressions, syntactically enclosed within curly brackets and separated by commas (in the case of a single alternative, curly brackets are omitted).

The combination of two alternative expressions results in the cartesian product combination of their alternatives.

Example alternative expressions:

1 + 2         => 3
{1,2} + 3     => {1+3,2+3}         => {4,5}
1 {+,*} 2     => {1+2,1*2}         => {3,2}
{1,2} + {9,7} => {1+9,1+7,2+9,2+7} => {10,8,11,9}

I've taken the bold step to generalise the above into the following:

Consecutive alternatives in a sequence that are equal are compressed into singletons, then prefixed with a colon, together with the multiplicity of the consecutive equal alternatives. A compressed representation of a sequence is called the canonical representation of a sequence.

Next to that, multiplicities are of type rational and can be negative (where negative multiplicities are prefixed with an underscore). Luckily, the cartesian product of alternatives can be naturally defined over negative and rational multiplicities.

Example canonical representations:

{1,1,1/4:2,2,_1/2:2,1,_3,_3,_3,3,1} =>

{1/2:1,1/4:2} + {4:3,_2:4}      => 
{2:(1+3),_(1+4),2+3,_1/2:(2+4)} =>
{2:4,_5,5,_1/2:6}               =>