Allow automatic sub-typing from variants of another data-type

[KtorZ]

The idea is to provide a way to create types that have constructor indexes at specific height, instead of being numbered from 0 onward. This is useful in combination with #889 as it can reduce the cost of casting a value into a type if a branch is only interested in a sub-part of the type.

For example, imagine a type:

type Foo {  
  A
  B
  C
}

When checking if something is of type Foo, we possibly have to check for constructor 0, 1 and 2 as well as any fields they may carry. Yet, we might only be interested in a specific variant (say, B). So, we could instrument the type-checker to only require a cast to Foo restricted to B. Fundamentally, B would be a record of a single constructor but with its constructor index equal to 1 and not to 0.

A possible syntax for that could be to piggyback on type-alias as such:

type PartialFoo = Foo::B

Which would be equivalent to defining:

type PartialFoo {
  B
}

[Quantumplation]

Similarly, would it be possible to explicitly declare constructor indices?

type PartialFoo {
  B @ctor(1)
  C @ctor(2)
  D @ctor(45)
}

[KtorZ]

This is where this idea came from. As a possible alternative.

[Quantumplation]

The explicit constructors would allow more flexibility when working with existing standards that may skip constructor indices, or when you want to only support a subset of cases in your contract.

In your proposal, I'd still have to define something with 45 variants before defining the subtype.

another alternative would be some methods for working with encoded terms directly in the prelude or stdlib?

[KtorZ]

I tend to agree. If we can define arbitrary constructor indexes, then we can always create a new type with a single variant to emulate what I am proposing originally.

Syntax-wise, I rather have the indices prefix the variant so that it's not confused with the field.

type Foo {
  1  A(Int, Bool)
  27 B 
  42 C { c0: ByteArray }
}

[Quantumplation]

Some other suggestions:

type Foo {
  1:  A(Int, Bool)
  27: B 
  42: C { c0: ByteArray }
}
type Foo {
  Constr(1)  A(Int, Bool)
  Constr(27) B 
  Constr(28) C { c0: ByteArray }
}
type Foo {
  (1)  A(Int, Bool)
  (27) B 
  (42) C { c0: ByteArray }
}