Experimental Support for Dependent Type Arguments - Step 1: Parsing

[odersky]

This PR introduces syntax and parsing for dependent type arguments. The plan is that these additions should eventually replace the current unsafe use of Singleton.

Two syntax forms:

Application: Types like

Vec[String](n)
Vec[String](10)

Type Abstraction :

type Vec[T] = (x: Int) =>> ...
type Vec[T](n: Int) = ...

Together:

type Matrix[T](m: Int, n: Int) = Vec[Vec[T](n)](m)

This is supported only under -language:experimental.dependent or the corresponding language import

import language.experimental.dependent

Types and typing rules are still missing, so actually using any of these (with the setting) will currently give "not yet implemented" errors in Typer.

Based on #8855

[odersky]

So far missing is support for term-dependent higher-kinded type parameters. For the time being it's better not to support them, at least until we have figured out the type inference situation.

[bblfish]

I came across this PR whilst trying to port banana-rdf to dotty.
I have a trait RDF { ... } which just specifies all the types needed for RDF. These then get implementations specifying types for existing RDF libraries.

In the current banana-rdf we use type projections, which no longer work. See my question on scala community for details.

I have been looking to see if I could just use implicits like this:

class PointedGraph(using val rdf: RDF)(pointer: rdf.Node, graph: rdf.Graph)

which is not that far from what we had before

class PointedGraph[Rdf<:RDF]( pointer: Rdf#Node, graph: Rdf#Graph)

But this leads to the following problem with code like this:

class PointedGraphs(using val ops: RDFOps)(
  val nodes: Iterable[ops.Rdf.Node], 
  val graph: ops.Rdf.Graph
) extends Iterable[PointedGraph] {
  import ops.Rdf

The problem is that the extends clause Iterable[PointedGraph] no longer has information about the ops type. And so we would need to pass that along in the definition and the methods like this:

 def /(p: Rdf.URI): PointedGraphs(ops) = {
    val ns: Iterable[Rdf.Node] = this flatMap { (pointed: PointedGraph) =>
      import pointed.pointer
      ops.getObjects(graph, pointer, p)
    }
    new PointedGraphs()(ns, graph)  // note though that one needs an extra () for the implicit
  }

If one adds the type info back then one now has double the work: one has to both keep track of the types, and also pass around the implicit object.