Question

I want to take this pattern:

 def accept[T](a: RList[T]) = true
 def accept[T, V](a: RList[T], b: RList[V])(implicit ev: a.S =:= b.S) = true
 def accept[T, V, Q](a: RList[T], b: RList[V], c: RList[Q])(implicit ev: a.S =:= b.S, ev2: b.S =:= c.S) = true

but have it accept a KList, instead of manually overriding for all arities. Basically I want to say, “Take any number of RLists, that have the same S member type”

RList is a trait, that contains a type S. (For more background on an RList and why I’m doing this, see: Constrain function based on origin (Path Dependent type? Type Generation?))

Answer 1

It looks like what you are doing is just trying to get the compiler to check that the types agree, since your methods ALWAYS return true.

Can you perhaps, instead of making methods which accept an arbitrary number of these, accept a “List of RLists” which is guaranteed to have S all matching?

Here is how such a list might be constructed:

package rl {

// A simplified version of your RList:
trait RList[T] {
  type S
  def data: List[T]
}

// A list of RLists which have identical S
sealed trait RListList 

// RListNil is an empty list
trait RListNil extends RListList {
  def ::[H <: RList[_]](h: H) = rl.::[h.S,H,RListNil](h, this)
}
// there is exactly one RListNil
case object RListNil extends RListNil

// List can be a cons cell of lists sharing the same S
final case class ::[S, H <: RList[_], T <: RListList](head: H, tail: T) extends RListList {

  // We only allow you to cons another to this if we can find evidence that the S matches
  def ::[H2 <: RList[_]](h: H2)(implicit ev: =:=[h.S,S]) = rl.::[S,H2,::[S,H,T]](h, this)
}

Now, if we try to construct a RListList that doesn’t have all the S types agreeing, the compiler will catch us:

object RListTest {

  val list1 = new RList[Int] { type S = String; def data = List(1,2,3,4) }
  val list2 = new RList[String] { type S = String; def data = List("1","2","3","4") }
  val list3 = new RList[Double] { type S = Float; def data = List(1.1,2.2,3.3,4.4) }

  val listOfLists1 = list1 :: RListNil // fine
  val listOfLists2 = list2 :: listOfLists1 // still fine, since list1 and list2 have the same S
  val listOfLists3 = list3 :: listOfLists2 // compiler error: Cannot prove that java.lang.String =:= Float

}

This is using dependent method types, which means you need to use scala 2.10 or you need to compile with the -Ydependent-method-types switch in 2.9.x