Rename is to forms

This is a trial balloon to see whether `forms` works better than `this`.

My immediate reaction is meh. Sometimes it's OK, at other times I liked `is` better.
But I admit there's bias since the examples were chosen to work well with `is`.

Author: odersky

docs/_docs/reference/experimental/typeclasses.md

@@ -134,11 +134,11 @@ We introduce a standard type alias `is` in the Scala package or in `Predef`, def
 This makes writing instance definitions quite pleasant. Examples:
 
 ```scala
-  given Int is Ord ...
-  given Int is Monoid ...
+  given Int forms Ord ...
+  given Int forms Monoid ...
 
   type Reader = [X] =>> Env => X
-  given Reader is Monad ...
+  given Reader forms Monad ...
 ```
 
 (more examples will follow below)
@@ -149,7 +149,7 @@ This makes writing instance definitions quite pleasant. Examples:
 
 Context bounds are a convenient and legible abbreviation. A problem so far is that they are always anonymous, one cannot name the using parameter to which a context bound expands. For instance, without the trick of defining a universal "trampoline" `unit` in the `Monoid` companion object, we would have to write `reduce` like this:
 ```scala
-  def reduce[A](xs: List[A])(using m: A is Monoid) =
+  def reduce[A](xs: List[A])(using m: A forms Monoid) =
     xs.foldLeft(m.unit)(_ `combine` _)
 ```
 
@@ -197,7 +197,7 @@ Context bounds are currently translated to implicit parameters in the last param
 ```
 With the current translation, this would give
 ```scala
-  def f[C](x: C.input)(using C: C is ParserCombinator)
+  def f[C](x: C.input)(using C: C forms ParserCombinator)
 ```
 But this is ill-typed, since the `C` in `C.input` refers to the `C` introduced in the using clause, which comes later.
 
@@ -254,7 +254,7 @@ type T: C
 in a trait will then expand to
 ```scala
 type T
-given T is C = deferred
+given T forms C = deferred
 ```
 
 
@@ -281,14 +281,14 @@ The awkwardness of the given syntax was forced upon us since we insisted that gi
 and we can use a more intuitive syntax for givens like this:
 
 ```scala
-given Int is Ord:
+given Int forms Ord:
   def compare(x: A, y: A) = ...
 
-given [A: Ord] => List[A] is Ord:
+given [A: Ord] => List[A] forms Ord:
   def compare(x: A, y: A) =
     ...
 
-given Int is Monoid as intMonoid:
+given Int forms Monoid as intMonoid:
   extension (x: Int) def combine(y: Int) = x + y
   def unit = 0
 ```
@@ -303,7 +303,7 @@ The underlying principles are:
     - an implementation which consists of either an `=` and an expression,
       or a template body.
 
- - We get the pleasing `<instance-type> is <type-class>` syntax simply by using the predefined infix type `is`.
+ - We get the pleasing `<instance-type> forms <type-class>` syntax simply by using the predefined infix type `forms`.
  - Since there is no more middle `:` separating name and parameters from the implemented type, we can use a `:` to start the class body without looking unnatural. That eliminates the special case where `with` was used before.
 
 This will be a fairly significant change to the given syntax. I believe there's still a possibility to do this,
@@ -326,7 +326,7 @@ This is less of a disruption than it might appear at first:
  - `given T` was illegal before since abstract givens could not be anonymous.
    It now means a concrete given of class `T` with no member definitions. This
    is the natural interpretation for simple tagging given clauses such as
-   `given String is Value`.
+   `given String forms Value`.
  - `given x: T` is legacy syntax for a deferred given.
  - `given T as x = deferred` is the analogous new syntax, which is more powerful since
     it allows for automatic instantiation.
@@ -396,14 +396,14 @@ Here are some standard type classes, which were mostly already introduced at the
 
   // Instances
 
-  given Int is Ord:
+  given Int forms Ord:
     extension (x: Int)
       def compareTo(y: Int) =
         if x < y then -1
         else if x > y then +1
         else 0
 
-  given [T: Ord] => List[T] is Ord:
+  given [T: Ord] => List[T] forms Ord:
     extension (xs: List[T]) def compareTo(ys: List[T]): Int =
       (xs, ys) match
       case (Nil, Nil) => 0
@@ -413,7 +413,7 @@ Here are some standard type classes, which were mostly already introduced at the
         val fst = x.compareTo(y)
         if (fst != 0) fst else xs1.compareTo(ys1)
 
-  given List is Monad:
+  given List forms Monad:
     extension [A](xs: List[A])
       def flatMap[B](f: A => List[B]): List[B] =
         xs.flatMap(f)
@@ -422,7 +422,7 @@ Here are some standard type classes, which were mostly already introduced at the
 
   type Reader[Ctx] = [X] =>> Ctx => X
 
-  given [Ctx] => Reader[Ctx] is Monad:
+  given [Ctx] => Reader[Ctx] forms Monad:
     extension [A](r: Ctx => A)
       def flatMap[B](f: A => Ctx => B): Ctx => B =
         ctx => f(r(ctx))(ctx)
@@ -443,7 +443,7 @@ Here are some standard type classes, which were mostly already introduced at the
   def maximum[T: Ord](xs: List[T]): T =
     xs.reduce(_ `max` _)
 
-  given [T: Ord] => T is Ord as descending:
+  given [T: Ord] => T forms Ord as descending:
     extension (x: T) def compareTo(y: T) = T.compareTo(y)(x)
 
   def minimum[T: Ord](xs: List[T]) =
@@ -483,11 +483,11 @@ trait TupleOf[+A]:
 
 object TupleOf:
 
-  given EmptyTuple is TupleOf[Nothing]:
+  given EmptyTuple forms TupleOf[Nothing]:
     type Mapped[+A] = EmptyTuple
     def map[B](x: EmptyTuple)(f: Nothing => B): Mapped[B] = x
 
-  given [A, Rest <: Tuple : TupleOf[A]] => A *: Rest is TupleOf[A]:
+  given [A, Rest <: Tuple : TupleOf[A]] => A *: Rest forms TupleOf[A]:
     type Mapped[+A] = A *: Rest.Mapped[A]
     def map[B](x: A *: Rest)(f: A => B): Mapped[B] =
       f(x.head) *: Rest.map(x.tail)(f)
@@ -532,14 +532,14 @@ end Combinator
 case class Apply[I, R](action: I => Option[R])
 case class Combine[A, B](a: A, b: B)
 
-given [I, R] => Apply[I, R] is Combinator:
+given [I, R] => Apply[I, R] forms Combinator:
   type Input = I
   type Result = R
   extension (self: Apply[I, R])
     def parse(in: I): Option[R] = self.action(in)
 
 given [A: Combinator, B: Combinator { type Input = A.Input }]
-    => Combine[A, B] is Combinator:
+    => Combine[A, B] forms Combinator:
   type Input = A.Input
   type Result = (A.Result, B.Result)
   extension (self: Combine[A, B])
@@ -567,7 +567,7 @@ to take the original example and show how it can be made to work with the new co
 _Note 2:_ One could improve the notation even further by adding equality constraints in the style of Swift, which in turn resemble the _sharing constraints_ of SML. A hypothetical syntax applied to the second given would be:
 ```scala
 given [A: Combinator, B: Combinator with A.Input == B.Input]
-    => Combine[A, B] is Combinator:
+    => Combine[A, B] forms Combinator:
 ```
 This variant is aesthetically pleasing since it makes the equality constraint symmetric. The original version had to use an asymmetric refinement on the second type parameter bound instead. For now, such constraints are neither implemented nor proposed. This is left as a possibility for future work. Note also the analogy with
 the work of @mbovel and @Sporarum on refinement types, where similar `with` clauses can appear for term parameters. If that work goes ahead, we could possibly revisit the issue of `with` clauses also for type parameters.

library/src/scala/runtime/stdLibPatches/Predef.scala

@@ -71,6 +71,6 @@ object Predef:
    *
    *  which is what is needed for a context bound `[A: TC]`.
    */
-  infix type is[A <: AnyKind, B <: {type Self <: AnyKind}] = B { type Self = A }
+  infix type forms[A <: AnyKind, B <: {type Self <: AnyKind}] = B { type Self = A }
 
 end Predef

tests/pos/FromString.scala

@@ -4,9 +4,9 @@ trait FromString:
   type Self
   def fromString(s: String): Self
 
-given Int is FromString = _.toInt
+given Int forms FromString = _.toInt
 
-given Double is FromString = _.toDouble
+given Double forms FromString = _.toDouble
 
 def add[N: {FromString, Numeric as num}](a: String, b: String): N =
   num.plus(N.fromString(a), N.fromString(b))

tests/pos/deferredSummon.scala

@@ -5,15 +5,15 @@ trait Ord:
 
 trait A:
   type Elem
-  given Elem is Ord = deferred
-  def foo = summon[Elem is Ord]
+  given Elem forms Ord = deferred
+  def foo = summon[Elem forms Ord]
 
 trait B:
   type Elem: Ord
-  def foo = summon[Elem is Ord]
+  def foo = summon[Elem forms Ord]
 
 object Inst:
-  given Int is Ord:
+  given Int forms Ord:
     def less(x: Int, y: Int) = x < y
 
 object Test1:

tests/pos/hylolib-extract.scala

@@ -14,11 +14,11 @@ trait Collection:
 
 class BitArray
 
-given Boolean is Value:
+given Boolean forms Value:
   extension (self: Self) def eq(other: Self): Boolean =
     self == other
 
-given BitArray is Collection:
+given BitArray forms Collection:
   type Element = Boolean
 
 extension [Self: Value](self: Self)

tests/pos/hylolib/AnyCollection.scala

@@ -38,7 +38,7 @@ object AnyCollection {
 
 }
 
-given [T: Value] => AnyCollection[T] is Collection:
+given [T: Value] => AnyCollection[T] forms Collection:
 
   type Element = T
   type Position = AnyValue

tests/pos/hylolib/AnyValue.scala

@@ -58,7 +58,7 @@ object AnyValue {
 
 }
 
-given AnyValue is Value:
+given AnyValue forms Value:
 
   extension (self: AnyValue)
     def copy(): AnyValue = self.copy()

tests/pos/hylolib/BitArray.scala

@@ -318,7 +318,7 @@ object BitArray {
 
 }
 
-given BitArray.Position is Value:
+given BitArray.Position forms Value:
 
   extension (self: BitArray.Position)
 
@@ -331,7 +331,7 @@ given BitArray.Position is Value:
     def hashInto(hasher: Hasher): Hasher =
       self.hashInto(hasher)
 
-given BitArray is Collection:
+given BitArray forms Collection:
 
   type Element = Boolean
   type Position = BitArray.Position
@@ -353,7 +353,7 @@ given BitArray is Collection:
     def at(p: BitArray.Position): Boolean =
       self.at(p)
 
-given BitArray is StringConvertible:
+given BitArray forms StringConvertible:
   extension (self: BitArray)
     override def description: String =
       var contents = mutable.StringBuilder()

tests/pos/hylolib/HyArray.scala

@@ -158,7 +158,7 @@ object HyArray {
 
 }
 
-given [T: Value] => HyArray[T] is Value:
+given [T: Value] => HyArray[T] forms Value:
 
   extension (self: HyArray[T])
 
@@ -171,7 +171,7 @@ given [T: Value] => HyArray[T] is Value:
     def hashInto(hasher: Hasher): Hasher =
       self.reduce(hasher)((h, e) => e.hashInto(h))
 
-given [T: Value] => HyArray[T] is Collection:
+given [T: Value] => HyArray[T] forms Collection:
 
   type Element = T
   type Position = Int
@@ -192,7 +192,7 @@ given [T: Value] => HyArray[T] is Collection:
 
     def at(p: Int) = self.at(p)
 
-given [T: {Value, StringConvertible}] => HyArray[T] is StringConvertible:
+given [T: {Value, StringConvertible}] => HyArray[T] forms StringConvertible:
   extension (self: HyArray[T])
     override def description: String =
       val contents = mutable.StringBuilder()

tests/pos/hylolib/Integers.scala

@@ -1,6 +1,6 @@
 package hylo
 
-given Boolean is Value:
+given Boolean forms Value:
 
   extension (self: Boolean)
 
@@ -14,7 +14,7 @@ given Boolean is Value:
     def hashInto(hasher: Hasher): Hasher =
       hasher.combine(if self then 1 else 0)
 
-given Int is Value:
+given Int forms Value:
 
   extension (self: Int)
 
@@ -28,7 +28,7 @@ given Int is Value:
     def hashInto(hasher: Hasher): Hasher =
       hasher.combine(self)
 
-given Int is Comparable:
+given Int forms Comparable:
 
   extension (self: Int)
 
@@ -43,4 +43,4 @@ given Int is Comparable:
 
     def lt(other: Int): Boolean = self < other
 
-given Int is StringConvertible
+given Int forms StringConvertible