Jtdylktuy

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.

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) {

     |   def getFirst[A](implicit comp: IsComposite[B] { type H = A }): A = b.head

     | }

// 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] {

     |   def getFirst[B <: Product](b: B)(implicit comp: IsComposite[B] { type H = A }): A = b.head

     | }

// 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)