# Dropped: Weak Conformance - More Details

To simplify the underlying type theory, Dotty drops the notion of weak conformance altogether. Instead, it provides more flexibility when assigning a type to a constant expression. The new rule is:

• If a list of expressions `Es` appears as one of

• the elements of a vararg parameter, or
• the alternatives of an if-then-else or match expression, or
• the body and catch results of a try expression,

and all expressions have primitive numeric types, but they do not all have the same type, then the following is attempted:

• the expressions `Es` are partitioned into `Int` constants on the one hand, and all other expressions on the other hand,
• if all the other expressions have the same numeric type `T` (which can be one of `Byte`, `Short`, `Char`, `Int`, `Long`, `Float`, `Double`), possibly after widening, and if none of the `Int` literals would incur a loss of precision when converted to `T`, then they are thus converted (the other expressions are left unchanged regardless),
• otherwise, the expressions `Es` are used unchanged.

A loss of precision occurs for an `Int -> Float` conversion of a constant `c` if `c.toFloat.toInt != c`. For an `Int -> Byte` conversion it occurs if `c.toByte.toInt != c`. For an `Int -> Short` conversion, it occurs if `c.toShort.toInt != c`.

### Examples

``````inline val b = 33
def f(): Int = b + 1
Array(b, 33, 5.5)      : Array[Double] // b is an inline val
Array(f(), 33, 5.5)    : Array[AnyVal] // f() is not a constant
Array(5, 11L)          : Array[Long]
Array(5, 11L, 5.5)     : Array[AnyVal] // Long and Double found
Array(1.0f, 2)         : Array[Float]
Array(1.0f, 1234567890): Array[AnyVal] // loss of precision
Array(b, 33, 'a')      : Array[Char]
Array(5.toByte, 11)    : Array[Byte]
``````