MapTupleN.scala

import scala.compiletime.ops.int.*

object MapTupleNExample {
  type TupleMapN[T <: NonEmptyTuple, N <: Int, A] =
    N < Tuple.Size[T] match {
      case true =>
        Tuple.Concat[
          Tuple.Take[T, N],
          A *: Tuple.Drop[T, N + 1]
        ]
    }

  final class Ops[N <: Int](val n: N) extends AnyVal {
    def apply[T <: NonEmptyTuple, A](
      tuple: T,
      f:     Tuple.Elem[T, N] => A
    ): TupleMapN[T, N, A] =
      Tuple
        .fromArray(
          tuple.take(n).toArray ++ (f(
            tuple(n).asInstanceOf[Tuple.Elem[T, N]]
          ).asInstanceOf[Object] +: tuple.drop(n + 1).toArray)
        )
        .asInstanceOf[TupleMapN[T, N, A]]
  }

  def tupleMapN[N <: Int](n: N): Ops[n.type] = new Ops[n.type](n)

  def typed[A](a: A): Unit = ()

  def main(args: Array[String]): Unit = {
    val x1 = tupleMapN(0)((2, "a", false), _.toString)
    typed[(String, String, Boolean)](x1)
    println(x1)
    assert(x1 == ("2", "a", false))

    val x2 = tupleMapN(2)((2, "a", Option(3), false, List("x")), _.map(x => x :: Nil))
    typed[(Int, String, Option[List[Int]], Boolean, List[String])](x2)
    println(x2)
    assert(x2 == (2, "a", Option(List(3)), false, List("x")))
  }
}