Add Tuple.mapKind method

library/src/scala/Tuple.scala

@@ -84,6 +84,13 @@ sealed trait Tuple extends Product {
   inline def map[F[_]](f: [t] => t => F[t]): Map[this.type, F] =
     runtime.Tuples.map(this, f).asInstanceOf[Map[this.type, F]]
 
+  /** Given a tuple of form `(F[T1], F[T2], ..., F[Tn])` and a function from F[T] to G[T] for any T out of T1...Tn,
+   * returns a new tuple `(G[T1], G[T2], ..., G[Tn])`.
+   */
+  inline def mapKind[F[_], G[_]](fk: [t <: Union[InverseMap[this.type, F]]] => F[t] => G[t]): MapKind[this.type, F, G] =
+    runtime.Tuples.map(this, fk.asInstanceOf).asInstanceOf[MapKind[this.type, F, G]]
+
+
   /** Given a tuple `(a1, ..., am)`, returns the tuple `(a1, ..., an)` consisting
    *  of its first n elements.
    */
@@ -220,6 +227,9 @@ object Tuple {
     case EmptyTuple => EmptyTuple
   }
 
+  /** Converts a tuple `(F[T1], F[T2], ..., F[Tn])` to `(G[T1], G[T2], ..., G[Tn])` */
+  type MapKind[T <: Tuple,  F[_], G[_]] = Map[InverseMap[T, F], G]
+
   /** Implicit evidence. IsMappedBy[F][X] is present in the implicit scope iff
    *  X is a tuple for which each element's type is constructed via `F`. E.g.
    *  (F[A1], ..., F[An]), but not `(F[A1], B2, ..., F[An])` where B2 does not

tests/run/Tuple-mapKind.scala

@@ -0,0 +1,39 @@
+object Test {
+
+  type Tup = (Int, Double, Boolean, String)
+
+  def main(args: Array[String]): Unit = {
+
+    val headOption: [x] => Seq[x] => Option[x] = [x] => (seq: Seq[x]) => seq.headOption
+    val firstTruthy: [T <: Tuple.Union[Tup]] => Seq[T] => Option[T] = [T <: Tuple.Union[Tup]] =>
+      (seq: Seq[T]) => seq.find {
+        case x: Int => x > 0
+        case x: Double => x > 0.0
+        case x: Boolean => x
+        case x: String => x.nonEmpty
+      }
+
+    val seqTuple: Tuple.Map[Tup, Seq] = (Vector(0, 1), Seq.empty, List(false, true), Vector("4", "44"))
+    val expectHeadOptionTuple: Tuple.Map[Tup, Option] = (Some(0), None, Some(false), Some("4"))
+    val expectFirstTruthyTuple: Tuple.Map[Tup, Option] = (Some(1), None, Some(true), Some("4"))
+
+    assert(
+      EmptyTuple.mapKind[Seq, Option](headOption) == EmptyTuple
+    )
+    assert(
+      EmptyTuple.mapKind[Seq, Option](firstTruthy) == EmptyTuple
+    )
+    assert(
+      (List("", "1") *: EmptyTuple).mapKind[Seq, Option](headOption) == (Some("") *: EmptyTuple)
+    )
+    assert(
+      (List("", "1") *: EmptyTuple).mapKind[Seq, Option](firstTruthy) == (Some("1") *: EmptyTuple)
+    )
+    assert(
+      seqTuple.mapKind[Seq, Option](headOption) == expectHeadOptionTuple
+    )
+    assert(
+      seqTuple.mapKind[Seq, Option](firstTruthy) == expectFirstTruthyTuple
+    )
+  }
+}