I'm simply referring to the original system that's diverged only due to the need for function parameter attributes that couldn't be represented in tuples themselves. But you're already aware of this so I won't elaborate over it too much. But even though it's diverged a little in one place it's still prevalent everywhere else.
Yes, exactly, this is the behaviour I'm advocating for (which is the current one).
No there wouldn't be. But we don't have "⟪⟫" or something else and there's nothing we can do about that now. We have parenthesis and the current behaviour is the most consistent behaviour we can have due to this IMO. See the relation between how expressions are reduced and how tuples are as well.
(5 + 5) * 2 == 20 // ('Int' + 'Int') * 'Int' == 'Int' ((5 + 5) * 2, (10)) == (20, 10) // (('Int' + 'Int') * 'Int', ('Int')) == ('Int', 'Int')
Note, I only meant for expression evaluation and type inference, sorry if I wasn't clear.
I don't see a problem here. You could also do this with structs or classes:
let t = Box(label: 12).label + Box(label: 34).label print(t) // 46
let t = (x: ..., x: ...) should be an ambiguity bug IMO, regardless of being able to use
.# as mentioned in the other thread.
let (a, x: b) = t would not be a problem if the above is fixed as it is only a consequence.
I think the fact that compiler crashes should be enough to say this is a bug . I imagine the program shouldn't compile when .true is droppped. Since
(true: Bool) != Bool and
! is not defined for it.
Most of the inconsistencies you mention are with dealing with labelled single element tuples. They are in my opinion are just bugs that need fixing.