More Scala typing issues

Question

Now that Kim Stebel helped me understanding how to type variables with existential types, i need to know how to use them in inheritance:

the following code doesn’t compile:

class PagingListModel(startPageNumber: Int, pageSize: Int, query: Query[Projection[_ <: Product]]) extends AbstractListModel {
    val itemStartNumber: Int = startPageNumber * pageSize
    val items: List[Product] = getPageData()

    override def getPageData(): List[Product] = {
        db withSession {
            return queryToQueryInvoker(query.drop(itemStartNumber).take(pageSize)).list
        }
    }
}

…with the error:

no type parameters for method queryToQueryInvoker:
(q: org.scalaquery.ql.Query[org.scalaquery.ql.ColumnBase[T]])
org.scalaquery.ql.basic.BasicQueryInvoker[T]
exist so that it can be applied to arguments
(org.scalaquery.ql.Query[org.scalaquery.ql.Projection[_ <: Product]])
--- because ---
argument expression's type is not compatible with formal parameter type;
found :   org.scalaquery.ql.Query[org.scalaquery.ql.Projection[_ <: Product]]
required: org.scalaquery.ql.Query[org.scalaquery.ql.ColumnBase[?T]]

…which is strange, because the required type is really inside the bounds of the found one…

PS: i really only want to be able to call foreach on each Tuple in the list returned by getPageData()…

szeiger · Accepted Answer · 2011-05-29T11:28:41.333

I don't think this can be done with an existential type. It works with a type parameter:

class PagingListModel[T <: Product](... query: Query[Projection[T]]) {
  ...
  def getPageData(): List[_ <: Product] = ...
    queryToQueryInvoker(query.drop(itemStartNumber).take(pageSize)).list
}

The original version would be correct but Scala cannot typecheck it due to a limitation similar to Haskell's monomorphism restriction. The type parameter for queryToQueryInvoker would have to be a universal type [T <: Product] forAll { type T } which is not supported by Scala.

By using an explicit type parameter, queryToQueryInvoker can be instantiated with that specific type. The method can still return List[_ <: Product] because List is co-variant in its element type.

Edit: It is possible after all. You have to move the existential to the right place:

class PagingListModel(... query: Query[Projection[T]] forSome { type T <: Product })  {
  def getPageData(): List[_ <: Product] = ... {
    val i = queryToQueryInvoker(query.drop(itemStartNumber).take(pageSize))
    i.list
  }
}

Without the extra variable i the compiler will infer the wrong type and then complain about it. Looks like a bug to me.

looks good! that certainly is one thing i never thought of the whole damn time i tried to find my mistake… — flying sheep, May 29 '11 at 12:20

score 1 · Answer 2 · answered May 28 '11 at 19:08

1

My knowledge of ScalaQuery is limited, but it looks as though you should be parameterizing the class.

class PagingListModel[T <: Product] (
  startPageNumber: Int,
  pageSize: Int,
  query: Query[Projection[T]]
) extends AbstractListModel {
  ...
}

Existentials can be tricky, and are best avoided if at all possible.

answered May 28 '11 at 19:08

Kevin Wright

49,540
9
105
155

i have thought of that, but when cunstructing a query, how to use it’s type in as type parameter then? – flying sheep May 29 '11 at 12:09
You shouldn't need to be explicit with the type param. The compiler will determine it for you based on the type of the `Projection` you supply as an argument. – Kevin Wright May 29 '11 at 21:08

More Scala typing issues

2 Answers2

Linked