Tuple methods

[FunFunFine]

Hi!
Currently, there are defined a lot of useful match types for Tuple, e.g. Fold, FlatMap, and so on.

But one thing that feels weird is there are no corresponding methods with said types. No method flatMap[F[_]](f: [A] => A => F[A]): FlatMap[T, F]. Not only it feels weird not to have them, but also it's quite hard to implement those correctly for not-so-experienced developers (for example I am not even sure about the signature of the flatMap method above).

So what are the plans for those methods? Should they be implemented at all?

[nicolasstucki]

One way to implement it is like this where we perform the operations on arrays.

import Tuple.FlatMap

extension (tup: Tuple)
  def flatMap[F[_] <: Tuple](f: [t] => t => F[t]): FlatMap[tup.type, F] =
    flatMapOnUnderlyingArrays(tup, f).asInstanceOf[FlatMap[tup.type, F]]

private def flatMapOnUnderlyingArrays[F[_] <: Tuple](self: Tuple, f: [t] => t => F[t]): Tuple = self match {
  case EmptyTuple => self
  case _ => Tuple.fromIArray(IArray.from(self.productIterator.flatMap(f(_).productIterator)))
}

def tests =
  val tup1: (Int, Int, String, String, Double, Double) = (1, "a", 3.0).flatMap[[t] =>> (t, t)]([t] => (x: t) => (x, x))
  ()

[nicolasstucki]

It seems we should add it to the library. See issue #13163.