Why are tuples right biased?

[jgogstad]

Hi,

Tuples in cats inherit all type class implementations from its "rightmost" type, e.g.

Welcome to the Ammonite Repl 2.5.0 (Scala 2.13.7 Java 11.0.11)
…
@ (true, 1).map(_ + 1)
res2: (Boolean, Int) = (true, 2)

Could someone elaborate on this design choice? Isn't it a bit weird?

1. It would be weird (my words) to let any product type inherit type class instances from its rightmost type, so if it doesn't make sense for Product3[A, B, C], why would it make sense for Tuple3[A, B, C]?
2. It causes code that looks wrong (like my example above) to compile, and in certain cases causes more surprising results:

   @ (1,2,3).sumAll
   res5: Int = 3
   @ (1,2).exists(_ == 1)
   res6: Boolean = false

Would it be better to define type class instances like Foldable and Monoid for tuples where every component is of the same type? and maybe Functor etc. where per-element semantics makes sense, and every component has a Functor instance?

[satorg]

Just to clarify your question. Tuples are heterogeneous by their nature. So what would you expect to get as a result in the case below:

("1", 2.34, '5', 6).sumAll

?

[jgogstad]

I would expect this to give a compilation error, I can't think of any semantics for sumAll that makes sense for Tuple4[String, Double, Char, Int]

[johnynek]

There are two questions here:

1. should there be a default Functor, Foldable, FlatMap, etc... for tuples?
2. if so, which element should be the preferred element?

I think there is an argument that the instances are too confusing and should not be in default scope. I am somewhat sympathetic to the idea that perhaps these should require an import.

On to the second question: if you are going to have an instance in scope, why is it the right most? The answer there, I believe has to do with scala's type inference with higher kinded types. I think eventually a right to left inference algorithm for higher kinded types, was fixed (I believe became default in 2.12 or 2.13). See this old bug for more information: scala/bug#2712

[jgogstad]

Thank you for the context. Being biased "to the right" is consistent with at least Either[A, B], and probably other types in predef that I can't think of. In that sense it's not "bad", but I think it gets confusing for tuples.

[djspiewak]

It might seem a bit less confusing if you think of Either and Tuple2 as being, in some sense, the same thing. They both contain "two" things, it's just that Tuple2 contains both of them, while Either only contains one at a time.

This notion, often called "duality" (the fact that they're secretly almost the same, not the fact that they have two things), shows up in other ways as well. For example, Either has a pretty obvious Monad instance (once you choose either left- or right-bias), and the implementation of the pure method is equal to just Right. However, Tuple2 cannot have a Monad! The reason being that you need to provide the "other" value for any definition of pure. The dual of this statement shows up as well: Tuple2 has an obvious Comonad instance (since the copure function is just _2), but Either cannot form a Comonad since you have no way to implement copure on Left.

Now that we've established (sort of) that Either and Tuple2 are kind of like mirror images of each other, we can continue to build on that intuition to infer other things. Mirrors are actually a really good way to envision duality in more ways than one. When you look into a mirror, the picture is inverted but only in one specific axis of symmetry, while everything else remains identical (i.e. you don't look upside down in a flat mirror). Duality is similar to this in that the inverted elements will be very specific while everything else remains the same.

In the case of Either and Tuple2, this means that certain elements can be thought of as "shared" and identical between the two duals, and in particular those elements are found in Functor and some of the other abstractions which relate to "having an A inside". Note that both Monad and Comonad extend Functor, so even the structure of the typeclass hierarchy hints at this just a little bit.

Ultimately, [A] ==>> Functor[(A, *)] makes exactly as much sense as [A] ==>> Functor[Either[A, *]], and has the same fundamental definition. The only question you need to answer is whether you bias to the left, or to the right.

[jgogstad]

Great answer, thanks!