So here's a cursed or blessed thought of mine recent times:
Everyone knows that the multiplicative conjunction is essentially a tuple, and that the additive disjunction is essentially a type-tagged union.
The quirk is, I found a familiar description for the additive conjunction. Namely, it's overloading.
The fuss is then, we can overload anything, as long as there aren't multiple declarations for the same type.
So for example, the integer literal 1 can be an overload of an 8-bit unsigned integer, a 64-bit signed integer, a 32-bit floating point, and many more as desired.
Another, crazier example is to have functions overloaded when they differ only in return types.
The craziness doesn't stop there. For consider a function with type signature Integer & String -> Bool. Such function shall accept only arguments that is overloaded as an integer and a string.
Possibly upcoming question: "My language can overload everything. How should its interactive interpreter query the type of such object?"
