mjhjmtu

If you want to do this without either boilerplate or runtime reflection, Shapeless is your best bet. You can use the IsComposite type class to put type-level constraints on the first element of a tuple:

import shapeless.ops.tuple.IsComposite

trait MustBeFirst

class MyClass[P <: Product](p: P)(implicit ev: IsComposite[P] type H = MustBeFirst ) 
 def getMustBeFirst(x: P): MustBeFirst = ev.head(p)

And then:

scala> val good2 = (new MustBeFirst , "")
good2: (MustBeFirst, String) = ($anon$1@7294acee,"")

scala> val good3 = (new MustBeFirst , "", 123)
good3: (MustBeFirst, String, Int) = ($anon$1@6eff9288,"",123)

scala> val good4 = (new MustBeFirst , "", 'xyz, 123)
good4: (MustBeFirst, String, Symbol, Int) = ($anon$1@108cdf99,"",'xyz,123)

scala> val bad2 = ("abc", 123)
bad2: (String, Int) = (abc,123)

scala> new MyClass(good2)
res0: MyClass[(MustBeFirst, String)] = MyClass@5297aa76

scala> new MyClass(good3)
res1: MyClass[(MustBeFirst, String, Int)] = MyClass@3f501844

scala> new MyClass(good4)
res2: MyClass[(MustBeFirst, String, Symbol, Int)] = MyClass@24e15478

scala> new MyClass(bad2)
<console>:15: error: could not find implicit value for parameter ev: shapeless.ops.tuple.IsComposite[(String, Int)]type H = MustBeFirst
 new MyClass(bad2)
 ^

If you need to use a trait, you can put the ev (for "evidence") requirement inside the definition instead of in the constructor:

trait MyTrait[P <: Product] 
 implicit def ev: IsComposite[P] type H = MustBeFirst 

Now any class instantiating MyTrait will have to provide evidence that P is a tuple with MustBeFirst as its first element.

Scala can't use generic tuple with unknown size because Products don's inherit themeselfs. You can try to use Shapeless or Products from play json lib.

Because tuples of differing sizes are (almost) unrelated types, if you need the compiler to type-check the calls to getMyClass() then you might have to overload it.

trait MyTrait 
 def getMyClass(x :(MyClass,_)) :MyClass = x._1
 def getMyClass(x :(MyClass,_,_)) :MyClass = x._1
 def getMyClass(x :(MyClass,_,_,_)) :MyClass = x._1
 def getMyClass(x :(MyClass,_,_,_,_)) :MyClass = x._1

You need to inherit your trait from Product, through which you can have productIterator, productArity and, productElement to handle the returned value. Here is an example

case class MyClass()

trait MyTrait[T <: Product] 
 def getMyClass(x: T): Option[MyClass] = 
 if(
 x.productIterator.hasNext 
 && 
 x.productIterator.next().isInstanceOf[MyClass]
 )
 Some(x.productIterator.next().asInstanceOf[MyClass])
 else 
 None
 


case class Test() extends MyTrait[Product]

And you can invoke like this

Test().getMyClass((MyClass(), 1,3,4,5))
//res1: Option[MyClass] = Some(MyClass())

Test().getMyClass((1,3,4,5))
//res2: Option[MyClass] = None

Hope this helps you.

As others said you can use shapeless:

import shapeless.ops.tuple.IsComposite
import shapeless.syntax.std.tuple._

class MyClass(i : Int)
 def hello() = println(i)



object Tup extends App 

 def getMyClass[P <: Product](p: P)(implicit ev: IsComposite[P]): MyClass = 
 if (p.head.isInstanceOf[MyClass]) p.head.asInstanceOf[MyClass] else throw new Exception()
 
 val x= (new MyClass(1),5,6)
 val y = (new MyClass(2),7)

 val c = getMyClass(x)
 val c1 = getMyClass(y)
 c.hello()
 c1.hello()

 val c2 = getMyClass((1,5,6,7)) // exception
 c2.hello()

If you are looking for compile time guarantee then this is one of the use cases for
Shapeless,

You need to add Shapeless in your build.sbt,

libraryDependencies ++= Seq("
 com.chuusai" %% "shapeless" % "2.3.3"
)

Now, you can use Shapeless to define a typesafe getter which comes with compile time guarantees,

scala> import shapeless._
// import shapeless._

scala> import ops.tuple.IsComposite
// import ops.tuple.IsComposite

scala> import syntax.std.tuple._
// import syntax.std.tuple._

scala> case class Omg(omg: String)
// defined class Omg

scala> val myStringTuple = ("All is well", 42, "hope")
// myStringTuple: (String, Int, String) = (All is well,42,hope)

scala> val myOmgTuple = (Omg("All is well"), 42, "hope")
// myOmgTuple: (Omg, Int, String) = (Omg(All is well),42,hope)

Now if you want to enrich your tuples with a "first" getter with a specific type then,

scala> implicit class GetterForProduct[B <: Product](b: B) 
 
// defined class GetterForProduct

scala> val myString = myStringTuple.getFirst[String]
// myString: String = All is well

scala> val myOmgError = myOmgTuple.getFirst[String]
// <console>:24: error: could not find implicit value for parameter comp: shapeless.ops.tuple.IsComposite[(Omg, Int, String)]type H = String
// val myOmgError = myOmgTuple.getFirst[String]
// ^

scala> val myOmg = myOmgTuple.getFirst[Omg]
// myOmg: Omg = Omg(All is well

If you don't need the implicit enrichment and are just looking for a way to "lock" the type in a getter and use it for corresponding types,

scala> trait FirstGetterInProduct[A] 
 
// defined trait FirstGetterInProduct

scala> object firstGetterInProductForString extends FirstGetterInProduct[String]
// defined object firstGetterInProductForString

scala> object firstGetterInProductForOmg extends FirstGetterInProduct[Omg]
// defined object firstGetterInProductForOmg

// Right tuple with right getter,
scala> val myString = firstGetterInProductForString.getFirst(myStringTuple)
// myString: String = All is well

// will fail at compile time for tuple with different type for first
scala> val myOmgError = firstGetterInProductForString.getFirst(myOmgTuple)
// <console>:23: error: could not find implicit value for parameter comp: shapeless.ops.tuple.IsComposite[(Omg, Int, String)]type H = String
// val myOmgError = firstGetterInProductForString.getFirst(myOmgTuple)
// ^

scala> val myOmg = firstGetterInProductForOmg.getFirst(myOmgTuple)
// myOmg: Omg = Omg(All is well)