Disallow refinements in GivenTypes

[odersky]

Test case is i2567.scala. We would like to write

class Foo given T {
  ...
}

But previously this mistook the class body as a refinement for T.

[anatoliykmetyuk]

I am not sure... Refinement types are allowed in the given part of the methods:

trait User
trait Order

trait TableName { type forEntity; val name: String }
object Instances {
  implied userTbl for TableName {
    type forEntity = User
    val name = "user"
  }

  implied orderTbl for TableName {
    type forEntity = Order
    val name = "order"
  }
}

object statements {
  def select[T] given TableName { type forEntity = T } =
    s"select * from ${the[TableName].name}"
}

import implied Instances._
println(statements.select[User ])  // select * from user
println(statements.select[Order])  // select * from order

So not allowing them in the constructors brings inconsistency. This can invite the following pattern:

  // class Statements[T] given TableName { type forEntity = T } {
  //   def select = s"select * from ${the[TableName].name}"
  //   def selectWhere(where: String) = s"select * from ${the[TableName].name} where ${where}"
  // }

  class Statements[T](tn: TableName { type forEntity = T }) {
    implied for TableName = tn
    def select = s"select * from ${the[TableName].name}"
    def selectWhere(where: String) = s"select * from ${the[TableName].name} where ${where}"
  }
  def Statements[T] given TableName { type forEntity = T } = new Statements[T](the[TableName])

  import implied Instances._
  println(Statements[User].selectWhere("id = 1"))

One thing that comes to mind is to allow for an optional syntax for class definitions as follows:

  class Statements[T] given TableName { type forEntity = T } = {
     /*...*/
  }

[odersky]

Good point. We could do one of two things:

1. Leave the PR as is, which means we require a named parameter list:

def select[T] given (ev: TableName { type forEntity = T })

2. Require AnnotTypes only for classes. This is more flexible since select can be written like this:

def select[T] given TableName { type forEntity = T }

But that would make it inconsistent between def parameters and class parameters. My tendency would be to pick (1).

[smarter]

Can we allow the following ?

  class Statements[T] given (TableName { type forEntity = T }) {
    // ...
  }

[odersky]

Can we allow the following ?

  class Statements[T] given (TableName { type forEntity = T }) {
    // ...
  }

Currently no. An opening ( starts a regular parameter list. But maybe we can fix the parser to allow it.

[anatoliykmetyuk]

Option 1 feels reasonable to me. Though the (TableName { type forEntity = T }) would also be nice to have.