I'm working on Scala 2.12.17.
Let's say I've a bunch of case classes:
case class TestOne(one: String)
case class TestTwo(one: String, two: String)
case class TestThree(one: String, two: String, three: String)
I also have these types:
trait Data {
  val a: Int
}
case class DoubleInt(a: Int, b: Int) extends Data
case class SingleInt(a: Int) extends Data
And this function which converts `Data` objects to `String`:
def loadData(input: Data): String = {
  input.a.toString
}
What I'm looking forward is to pass `Data` object(s) to my case class's apply method, then the apply method would use `loadData` function in order to convert each passed `Data` object into a `String` to make an instance of my case class. E.g:
val dataOne: Data = SingleInt(1)
val dataTwo: Data = DoubleInt(1, 2)
val testOne = TestOne(dataOne)
val testTwo = TestTwo(dataOne, dataTwo)
val testThree = TestOne(dataOne, dataTwo, dataOne)
Basically, `TestOne` `apply` method would be:
def apply(one: Data): TestOne = {
  new TestOne(loadData(one))
}
`TestTwo` `apply` method would be:
def apply(one: Data, two: Data): TestTwo = {
  new TestTwo(loadData(one), loadData(two))
}
Is there any way to programmatically generate those apply methods at compile time?
I thought that macros or paradise annotations would be useful for this use case, but I'm too inexperienced with these topics to even know where to start :/

Should
    val testThree = TestOne(dataOne, dataTwo, dataOne)
be `val testThree = TestThree(dataOne, dataTwo, dataOne)`?
So you'd like to replace

with just

Mapping over a tuple or case class is a standard task, for example, for [Shapeless][1]
```scala
// libraryDependencies += "com.chuusai" %% "shapeless" % "2.3.10"
import shapeless.poly.->
import shapeless.syntax.std.tuple._
object loadDataPoly extends (Data -> String)(loadData)
val testOne = TestOne(loadData(dataOne))
val testTwo = TestTwo.tupled((dataOne, dataTwo).map(loadDataPoly))
val testThree = TestThree.tupled((dataOne, dataTwo, dataOne).map(loadDataPoly))

import shapeless.{Generic, HList}
import shapeless.ops.traversable.FromTraversable
def make[A <: Product] = new PartiallyAppliedMake[A]
class PartiallyAppliedMake[A <: Product] {
  def apply[L <: HList](data: Data*)(implicit
    generic: Generic.Aux[A, L],
    fromTraversable: FromTraversable[L]
  ): A = generic.from(fromTraversable(data.map(loadData)).get)
}
val testOne = make[TestOne](dataOne)
val testTwo = make[TestTwo](dataOne, dataTwo)
val testThree = make[TestThree](dataOne, dataTwo, dataOne)
val testThree_ = make[TestThree](dataOne, dataTwo, dataOne, dataOne) // fails at runtime

import shapeless.{Generic, HList, Nat}
import shapeless.ops.hlist.{Mapper, Length, Fill}
import shapeless.ops.function.FnFromProduct
def make[TestClass <: Product] = new PartiallyAppliedMake[TestClass]
class PartiallyAppliedMake[TestClass <: Product] {
  def apply[StringHList <: HList, N <: Nat, DataHList <: HList]()(implicit
    generic: Generic.Aux[TestClass, StringHList],
    length: Length.Aux[StringHList, N],
    fill: Fill.Aux[N, Data, DataHList],
    mapper: Mapper.Aux[loadDataPoly.type, DataHList, StringHList],
    fnFromProduct: FnFromProduct[DataHList => TestClass]
  ): fnFromProduct.Out =
    fnFromProduct((l: DataHList) => generic.from(mapper(l)))
}
val testOne = make[TestOne]().apply(dataOne)
val testTwo = make[TestTwo]().apply(dataOne, dataTwo)
val testThree = make[TestThree]().apply(dataOne, dataTwo, dataOne)
val testThree_ = make[TestThree]().apply(dataOne, dataTwo, dataOne, dataOne) // fails at compile time

// libraryDependencies += scalaOrganization.value % "scala-reflect" % scalaVersion.value
import scala.language.experimental.macros
import scala.reflect.macros.blackbox
def make[A](data: Data*): A = macro makeImpl[A]
def makeImpl[A: c.WeakTypeTag](c: blackbox.Context)(data: c.Tree*): c.Tree = {
  import c.universe._
  val A = weakTypeOf[A]
  val strs = data.map(t => q"loadData($t)")
  q"new $A(..$strs)"
}

// in a different subproject
val testOne = make[TestOne](dataOne) // TestOne(1)
val testTwo = make[TestTwo](dataOne, dataTwo) // TestTwo(1,1)
val testThree = make[TestThree](dataOne, dataTwo, dataOne) // TestThree(1,1,1)
val testThree_ = make[TestThree](dataOne, dataTwo, dataOne, dataOne) // doesn't compile: too many arguments (found 4, expected 3) ...

// addCompilerPlugin("org.scalamacros" % "paradise" % "2.1.1" cross CrossVersion.full) // Scala 2.12
import scala.annotation.{StaticAnnotation, compileTimeOnly}
import scala.language.experimental.macros
import scala.reflect.macros.blackbox
@compileTimeOnly("enable macro annotations")
class generateApply extends StaticAnnotation {
  def macroTransform(annottees: Any*): Any = macro GenerateApplyMacro.macroTransformImpl
}
object GenerateApplyMacro {
  def macroTransformImpl(c: blackbox.Context)(annottees: c.Tree*): c.Tree = {
    import c.universe._
    def modify(cls: ClassDef, obj: ModuleDef): Tree = (cls, obj) match {
      case (
        q"$_ class $tpname[..$tparams] $_(...$paramss) extends { ..$_ } with ..$_ { $_ => ..$_ }",
        q"$mods object $tname extends { ..$earlydefns } with ..$parents { $self => ..$body }"
      ) =>
        val paramss1 = paramss.map(_.map {
          case q"$mods val $tname: $_ = $_" => q"$mods val $tname: Data"
        })
        val argss = paramss.map(_.map {
          case q"$_ val $tname: $_ = $_" => q"loadData($tname)"
        })
        val targs = tparams.map {
          case q"$_ type $tpname[..$_] = $tpt" => tq"$tpname"
        }
        q"""
          $cls
          $mods object $tname extends { ..$earlydefns } with ..$parents { $self =>
            def apply[..$tparams](...$paramss1): $tpname[..$targs] = {
              new $tpname[..$targs](...$argss)
            }
            ..$body
          }
        """
    }
    annottees match {
      case (cls: ClassDef) :: (obj: ModuleDef) :: Nil => modify(cls, obj)
      case (cls: ClassDef) :: Nil => modify(cls, q"object ${cls.name.toTermName}")
    }
  }
}

// in a different subproject
@generateApply case class TestOne(one: String)
@generateApply case class TestTwo(one: String
<details>
<summary>英文:</summary>
Should
    val testThree = TestOne(dataOne, dataTwo, dataOne)
be `val testThree = TestThree(dataOne, dataTwo, dataOne)`?
So you&#39;d like to replace 

with just

Mapping over a tuple or case class is a standard task for example for [Shapeless][1]

If you want to hide `load` at all you can define a generic method

If you want `make` to fail at compile time if the number of arguments is incorrect then the definition is a little more complicated 

Or you can define a [def macro][2]

// scalacOptions += "-Ymacro-debug-lite"

But if you really want to generate `apply` methods in companion objects you can define [macro annotaion][3] (settings: https://stackoverflow.com/questions/74497076/auto-generate-companion-object-for-case-class-in-scala)

def modify(cls: ClassDef, obj: ModuleDef): Tree = (cls, obj) match {
case (
q"$_ class $tpname[..$tparams] $_(...$paramss) extends { ..$_ } with ..$_ { $_ => ..$_ }",
q"$mods object $tname extends { ..$earlydefns } with ..$parents { $self => ..$body }"
) =>
val paramss1 = paramss.map(_.map {
case q"$mods val $tname: $_ = $_" => q"$mods val $tname: Data"
})
val argss = paramss.map(_.map {
case q"$_ val $tname: $_ = $_" => q"loadData($tname)"
})
val targs = tparams.map {
case q"$_ type $tpname[..$_] = $tpt" => tq"$tpname"
}
q"""
$cls
$mods object $tname extends { ..$earlydefns } with ..$parents { $self =>
def apply[..$tparams](...$paramss1): $tpname[..$targs] = {
new $tpname[..$targs](...$argss)
}
..$body
}
"""
}
annottees match {
case (cls: ClassDef) :: (obj: ModuleDef) :: Nil => modify(cls, obj)
case (cls: ClassDef) :: Nil => modify(cls, q"object ${cls.name.toTermName}")
}

[1]: https://github.com/milessabin/shapeless
[2]: https://docs.scala-lang.org/overviews/macros/overview.html
[3]: https://docs.scala-lang.org/overviews/macros/annotations.html
</details>