Qfyilyi

I have a generic method that can accept any tuple of any size, the only constraint is that the first element of this tuple should be of type MyClass.

Something like this:

trait MyTrait[T <: (MyClass, _*)] {

  getMyClass(x: T): MyClass = x._1

}

I've tried this

trait MyTrait[T <: (MyClass, _) with (MyClass, _, _) with (MyClass, _, _) with ...] {

  getMyClass(x: T): MyClass = x._1

}

but I get the error unboud wildcard type

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.

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

And then:

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.

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.

It's a little bit unsafe but you can use Structural type in this case:

trait MyTrait {

  def getMyClass(x: {def _1: MyClass}): MyClass = x._1

}

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



}