To put a different spin on it, in the dual case we can show that Haskell's
(,) is not a categorical product. There's a good deal of historical debate
about why it works the way it does, but if we're looking to make a better
system then the fact that tuples are not well-behaved suggests a place for
improvement. The current (,) is a compromise between two different notions
of product in domain theory. On the one hand we have domain products
(which do not produce domains) and on the other hand we have smash
products (which can "lose" information). I've had in mind for a while to
make a Haskell-like language with a total functional core. In a total
language (even a lazy one), we don't have bottom so we don't need domain
theory to reason about the language. So in a language which is only
partially total, it's reasonable to have two different kinds of
products--- which means we can get away from Haskell's compromise, but do
so in a way that's harmonious with the rest of the language. Would this
new system be "better"? I dunno. It would behave in a more lawful manner,
so it should be easier to reason about; but then we're making programmers
keep that reasoning in mind, and maybe that's too much work. A decent
system has to be both correct but also usable, and human factors are messy
and hard to predict.