Change to new syntax in pos-custom-args

Author: odersky

tests/pos-custom-args/bounded1.scala

@@ -1,27 +1,27 @@
 // To be revisited
 class CC
-type Cap = {*} CC
+type Cap = CC^
 
 def test(c: Cap) =
-  class B[X <: {c} Object](x: X):
+  class B[X <: Object^{c}](x: X):
     def elem = x
     def lateElem = () => x
 
   def f(x: Int): Int = if c == c then x else 0
   val b = new B(f)
   val r1 = b.elem
-  val r1c: {c} Int -> Int = r1
+  val r1c: Int^{c} -> Int = r1
   val r2 = b.lateElem
-  val r2c: () -> {c} Int -> Int = r2 // was error now OK
+  val r2c: () -> Int^{c} -> Int = r2 // was error now OK
 
 def test2(c: Cap) =
-  class B[X <: {*} Any](x: X):
+  class B[X <: Any^](x: X):
     def elem = x
     def lateElem = () => x
 
   def f(x: Int): Int = if c == c then x else 0
   val b = new B(f)
   val r1 = b.elem
-  val r1c: {c} Int -> Int = r1
+  val r1c: Int ->{c} Int = r1
   val r2 = b.lateElem
-  val r2c: () -> {c} Int -> Int = r2 // was error now OK
+  val r2c: () -> Int ->{c} Int = r2 // was error now OK

tests/pos-custom-args/captures/bounded.scala

@@ -1,14 +1,14 @@
 class CC
-type Cap = {*} CC
+type Cap = CC^
 
 def test(c: Cap) =
-  class B[X <: {c} Object](x: X):
+  class B[X <: Object^{c}](x: X):
     def elem = x
     def lateElem = () => x
 
   def f(x: Int): Int = if c == c then x else 0
   val b = new B(f)
   val r1 = b.elem
-  val r1c: {c} Int -> Int = r1
+  val r1c: Int ->{c} Int = r1
   val r2 = b.lateElem
-  val r2c: {c} () -> {c} Int -> Int = r2
+  val r2c: () ->{c} Int ->{c} Int = r2

tests/pos-custom-args/captures/boxed1.scala

@@ -6,6 +6,6 @@ def foo(x: => Int): Unit = ()
 
 def test(c: Cap) =
   val f = () => { c; 1 }
-  val _: {c} () -> Int = f
+  val _: () ->{c} Int = f
   val g = () => Box(f)
-  val _: () -> Box[{f} () -> Int] = g
+  val _: () -> Box[() ->{f} Int] = g

tests/pos-custom-args/captures/boxmap-paper.scala

@@ -12,25 +12,25 @@ def map[A, B](c: Cell[A])(f: A => B): Cell[B]
 def pureMap[A, B](c: Cell[A])(f: A -> B): Cell[B]
   = c[Cell[B]]((x: A) => cell(f(x)))
 
-def lazyMap[A, B](c: Cell[A])(f: A => B): {f} () -> Cell[B]
+def lazyMap[A, B](c: Cell[A])(f: A => B): () ->{f} Cell[B]
   = () => c[Cell[B]]((x: A) => cell(f(x)))
 
 trait IO:
   def print(s: String): Unit
 
-def test(io: {*} IO) =
+def test(io: IO^) =
 
-  val loggedOne: {io} () -> Int = () => { io.print("1"); 1 }
+  val loggedOne: () ->{io} Int = () => { io.print("1"); 1 }
 
-  val c: Cell[{io} () -> Int]
-      = cell[{io} () -> Int](loggedOne)
+  val c: Cell[() ->{io} Int]
+      = cell[() ->{io} Int](loggedOne)
 
-  val g = (f: {io} () -> Int) =>
+  val g = (f: () ->{io} Int) =>
     val x = f(); io.print(" + ")
     val y = f(); io.print(s" = ${x + y}")
 
-  val r = lazyMap[{io} () -> Int, Unit](c)(f => g(f))
-  val r2 = lazyMap[{io} () -> Int, Unit](c)(g)
+  val r = lazyMap[() ->{io} Int, Unit](c)(f => g(f))
+  val r2 = lazyMap[() ->{io} Int, Unit](c)(g)
   val r3 = lazyMap(c)(g)
   val _ = r()
   val _ = r2()

tests/pos-custom-args/captures/caps-universal.scala

@@ -2,6 +2,6 @@ import annotation.retains
 
 val foo: Int => Int = x => x
 val bar: (Int -> Int) @retains(caps.*) = foo
-val baz: {*} Int -> Int = bar
+val baz: Int => Int = bar
 
 

tests/pos-custom-args/captures/capt-capability.scala

@@ -1,7 +1,7 @@
 import annotation.capability
 
 @capability class Cap
-def f1(c: Cap): {c} () -> c.type = () => c // ok
+def f1(c: Cap): () ->{c} c.type = () => c // ok
 
 def f2: Int =
   val g: Boolean => Int = ???
@@ -17,8 +17,8 @@ def f3: Int =
 def foo() =
   val x: Cap = ???
   val y: Cap = x
-  val x2: {x} () -> Cap = ???
-  val y2: {x} () -> Cap = x2
+  val x2: () ->{x} Cap = ???
+  val y2: () ->{x} Cap = x2
 
   val z1: () => Cap = f1(x)
   def h[X](a: X)(b: X) = a

tests/pos-custom-args/captures/capt-depfun.scala

@@ -16,6 +16,6 @@ def f(y: Cap, z: Cap): String @retains(caps.*) =
   val d = a(g())
 
   val ac: ((x: Cap) -> ID[String @retains(x) -> String @retains(x)]) = ???
-  val bc: (({y} String) -> {y} String) = ac(y)
-  val dc: (String -> {y, z} String) = ac(g())
+  val bc: String^{y} -> String^{y} = ac(y)
+  val dc: String -> String^{y, z} = ac(g())
   c

tests/pos-custom-args/captures/capt-depfun2.scala

@@ -5,5 +5,5 @@ type Cap = C @retains(caps.*)
 def f(y: Cap, z: Cap) =
   def g(): C @retains(y, z) = ???
   val ac: ((x: Cap) -> Array[String @retains(x)]) = ???
-  val dc: Array[? >: String <: {y, z} String] = ac(g()) // needs to be inferred
+  val dc: Array[? >: String <: String]^{y, z} = ac(g()) // needs to be inferred
   val ec = ac(y)

tests/pos-custom-args/captures/capt0.scala

@@ -1,7 +1,7 @@
 object Test:
 
   def test() =
-    val x: {*} Any = "abc"
+    val x: Any^ = "abc"
     val y: Object @scala.annotation.retains(x) = ???
     val z: Object @scala.annotation.retains(x, caps.*) = y: Object @annotation.retains(x)
 

tests/pos-custom-args/captures/capt2.scala

@@ -3,7 +3,7 @@ class C
 type Cap = C @retains(caps.*)
 
 def test1() =
-  val y: {*} String = ""
+  val y: String^ = ""
   def x: Object @retains(y) = y
 
 def test2() =
@@ -13,8 +13,8 @@ def test2() =
   z: (() -> Unit) @retains(x)
   def z2: (() -> Unit) @retains(y) = y
   z2: (() -> Unit) @retains(y)
-  val p: {*} () -> String = () => "abc"
-  val q: {p} C = ???
-  val _ = p: ({p} () -> String)
+  val p: () => String = () => "abc"
+  val q: C^{p} = ???
+  val _ = p: (() ->{p} String)
 
 

tests/pos-custom-args/captures/caseclass.scala

@@ -1,6 +1,6 @@
 @annotation.capability class C
 object test1:
-  case class Ref(x: {*} String)
+  case class Ref(x: String^)
 
   def test(c: C) =
     val x1 = Ref("hello")
@@ -14,7 +14,7 @@ object test2:
 
     val pure: () -> Unit = () => ()
     val impure: () => Unit = pure
-    val mixed: {c} () -> Unit = pure
+    val mixed: () ->{c} Unit = pure
     val x = Ref(impure)
     val y0 = x.copy(pure)
     val yc0: Ref = y0
@@ -25,10 +25,10 @@ object test2:
     val yc2: Ref = y2
 
     val x3 = Ref(mixed)
-    val _: {c} Ref = x3
+    val _: Ref^{c} = x3
     val y3 = x3.copy()
-    val yc3: {c} Ref = y3
+    val yc3: Ref^{c} = y3
 
     val y4 = y3 match
       case Ref(xx) => xx
-    val y4c: {x3} () -> Unit = y4
+    val y4c: () ->{x3} Unit = y4

tests/pos-custom-args/captures/cc-expand.scala

@@ -9,7 +9,7 @@ object Test:
 
   def test(ct: CT, dt: CT) =
 
-    def x0: A -> {ct} B = ???
+    def x0: A -> B^{ct} = ???
 
     def x1: A -> B @retains(ct) = ???
     def x2: A -> B -> C @retains(ct) = ???

tests/pos-custom-args/captures/cc-this.scala

@@ -5,7 +5,7 @@ def eff(using Cap): Unit = ()
 def test(using Cap) =
 
   class C(val x: () => Int):
-    val y: {*} C = this
+    val y: C^ = this
 
   def f = () =>
     eff
@@ -14,4 +14,4 @@ def test(using Cap) =
   def c1 = new C(f)
   def c2 = c1
   def c3 = c2.y
-  val _ = c3: {*} C
+  val _ = c3: C^

tests/pos-custom-args/captures/compare-refined.scala

@@ -2,11 +2,11 @@ abstract class LIST[+T]:
   def map[U](f: T => U): LIST[U] = ???
 
 class C
-type Cap = {*} C
+type Cap = C^
 
 def test(d: Cap) =
-  val zsc: LIST[{d} Cap -> Unit] = ???
-  val a4 = zsc.map[{d} Cap -> Unit]((x: {d} Cap -> Unit) => x)
-  val a5 = zsc.map[{d} Cap -> Unit](identity[{d} Cap -> Unit])
-  val a6 = zsc.map(identity[{d} Cap -> Unit])
+  val zsc: LIST[Cap ->{d} Unit] = ???
+  val a4 = zsc.map[Cap ->{d} Unit]((x: Cap ->{d} Unit) => x)
+  val a5 = zsc.map[Cap ->{d} Unit](identity[Cap ->{d} Unit])
+  val a6 = zsc.map(identity[Cap ->{d} Unit])
   val a7 = zsc.map(identity)

tests/pos-custom-args/captures/curried-shorthands.scala

@@ -10,15 +10,15 @@ object Test:
   val f3 = (f: Int => Int) =>
     println(f(3))
     (xs: List[Int]) => xs.map(_ + 1)
-  val f3c: (Int => Int) -> {} List[Int] -> List[Int] = f3
+  val f3c: (Int => Int) -> List[Int] ->{} List[Int] = f3
 
   class LL[A]:
-    def drop(n: Int): {this} LL[A] = ???
+    def drop(n: Int): LL[A]^{this} = ???
 
   def test(ct: CanThrow[Exception]) =
-    def xs: {ct} LL[Int] = ???
+    def xs: LL[Int]^{ct} = ???
     val ys = xs.drop(_)
-    val ysc: Int -> {ct} LL[Int] = ys
+    val ysc: Int -> LL[Int]^{ct} = ys
 
 
 

tests/pos-custom-args/captures/filevar.scala

@@ -6,10 +6,10 @@ object test1:
   class File:
     def write(x: String): Unit = ???
 
-  class Service(f: {*} File):
+  class Service(f: File^):
     def log = f.write("log")
 
-  def withFile[T](op: (f: {*} File) => T): T =
+  def withFile[T](op: (f: File^) => T): T =
     op(new File)
 
   def test =
@@ -24,10 +24,10 @@ object test2:
     def write(x: String): Unit = ???
 
   class Service(io: IO):
-    var file: {io} File = uninitialized
+    var file: File^{io} = uninitialized
     def log = file.write("log")
 
-  def withFile[T](io: IO)(op: (f: {io} File) => T): T =
+  def withFile[T](io: IO)(op: (f: File^{io}) => T): T =
     op(new File)
 
   def test(io: IO) =

tests/pos-custom-args/captures/hk-param.scala

@@ -1,17 +1,17 @@
 /** Concrete collection type: View */
-trait View[+A] extends Itable[A], ILike[A, [X] =>> {*} View[X]]:
-  override def fromIterable[B](c: {*} Itable[B]): {c} View[B] = ???
+trait View[+A] extends Itable[A], ILike[A, [X] =>> View[X]^]:
+  override def fromIterable[B](c: Itable[B]^): View[B]^{c} = ???
 
 trait IPolyTransforms[+A, +C[A]] extends Any:
-  def fromIterable[B](coll: {*} Itable[B]): C[B]
+  def fromIterable[B](coll: Itable[B]^): C[B]
 
-trait ILike[+A, +C[X] <: {*} Itable[X]] extends IPolyTransforms[A, C]
+trait ILike[+A, +C[X] <: Itable[X]^] extends IPolyTransforms[A, C]
 
 /** Base trait for generic collections */
-trait Itable[+A] extends ItableOnce[A] with ILike[A, {*} Itable]
+trait Itable[+A] extends ItableOnce[A] with ILike[A, Itable^]
 
 /** Iterator can be used only once */
 trait ItableOnce[+A] {
-  this: {*} ItableOnce[A] =>
-  def iterator: {this} Iterator[A]
+  this: ItableOnce[A]^ =>
+  def iterator: Iterator[A]^{this}
 }

tests/pos-custom-args/captures/i15922.scala

@@ -2,13 +2,13 @@ trait Cap { def use(): Int }
 type Id[X] = [T] -> (op: X => T) -> T
 def mkId[X](x: X): Id[X] = [T] => (op: X => T) => op(x)
 
-def withCap[X](op: ({*} Cap) => X): X = {
-  val cap: {*} Cap = new Cap { def use() = { println("cap is used"); 0 } }
+def withCap[X](op: (Cap^) => X): X = {
+  val cap: Cap^ = new Cap { def use() = { println("cap is used"); 0 } }
   val result = op(cap)
   result
 }
 
-def leaking(c: {*} Cap): Id[{c} Cap] = mkId(c)
+def leaking(c: Cap^): Id[Cap^{c}] = mkId(c)
 
 def test =
   val bad = withCap(leaking)

tests/pos-custom-args/captures/i16116.scala

@@ -17,7 +17,7 @@ object Test {
 
   @capability
   class CpsTransform[F[_]] {
-     def await[T](ft: F[T]): { this } T = ???
+     def await[T](ft: F[T]): T^{ this } = ???
   }
 
   transparent inline def cpsAsync[F[_]](using m:CpsMonad[F]) =
@@ -27,7 +27,7 @@ object Test {
       def apply[A](expr: (CpsTransform[F], C) ?=> A): F[A] = ???
   }
 
-  def asyncPlus[F[_]](a:Int, b:F[Int])(using cps: CpsTransform[F]): { cps } Int =
+  def asyncPlus[F[_]](a:Int, b:F[Int])(using cps: CpsTransform[F]): Int^{ cps } =
     a + (cps.await(b).asInstanceOf[Int])
 
   def testExample1Future(): Unit =

tests/pos-custom-args/captures/i16226.scala

@@ -1,14 +1,14 @@
 @annotation.capability class Cap
 
 class LazyRef[T](val elem: () => T):
-  val get: {elem} () -> T = elem
-  def map[U](f: T => U): {f, this} LazyRef[U] =
+  val get: () ->{elem} T = elem
+  def map[U](f: T => U): LazyRef[U]^{f, this} =
     new LazyRef(() => f(elem()))
 
-def map[A, B](ref: {*} LazyRef[A], f: A => B): {f, ref} LazyRef[B] =
+def map[A, B](ref: LazyRef[A]^, f: A => B): LazyRef[B]^{f, ref} =
   new LazyRef(() => f(ref.elem()))
 
 def main(io: Cap) = {
-  def mapd[A, B]: ({io} LazyRef[A], A => B) => {*} LazyRef[B] =
+  def mapd[A, B]: (LazyRef[A]^{io}, A => B) => LazyRef[B]^ =
     (ref1, f1) => map[A, B](ref1, f1)
 }

tests/pos-custom-args/captures/iterators.scala

@@ -1,19 +1,19 @@
 package cctest
 
 abstract class Iterator[T]:
-  thisIterator: {*} Iterator[T] =>
+  thisIterator: Iterator[T]^ =>
 
   def hasNext: Boolean
   def next: T
-  def map(f: {*} T => T): {f, this} Iterator[T] = new Iterator:
+  def map(f: T => T): Iterator[T]^{f, this} = new Iterator:
     def hasNext = thisIterator.hasNext
     def next = f(thisIterator.next)
 end Iterator
 
 class C
-type Cap = {*} C
+type Cap = C^
 
-def map[T, U](it: {*} Iterator[T], f: {*} T => U): {it, f} Iterator[U] = new Iterator:
+def map[T, U](it: Iterator[T]^, f: T^ => U): Iterator[U]^{it, f} = new Iterator:
   def hasNext = it.hasNext
   def next = f(it.next)