Allow changing the type of a value when the variant is inferred and not all type parameters are used

[GearsDatapacks]

For example, this code currently does not compile:

fn map(result: Result(a, e), f: fn(a) -> b) -> Result(b, e) {
  case result {
    Ok(a) -> Ok(f(a))
    Error(_) -> result
  }
}

Because result has type Result(a, e) not Result(b, e). The compiler can however infer that result must be of variant Error, and since Error makes no reference to the a type parameter, this would not create an invalid value.

However, I'm not sure how this would work with phantom types. If we weren't careful, this would entirely defeat the point of phantom types:

type Money(currency) {
  Money(Int)
}
type Euro
type Pound

pub fn main() {
  let euros: Money(Euro) = Money(10)
  let pounds: Money(Pound) = euros // Valid, since the `Money` variant makes no reference to the `currency` type parameter.
}

Not sure how we would work around that

[lpil]

Converted this to a discussion as it's unclear what we would be doing here