Hylolib: Use name of bound parameter for context bounds

Author: odersky

tests/pos/hylolib-extract.scala

@@ -23,3 +23,7 @@ given BitArray is Collection:
 
 extension [Self: Value](self: Self)
   def neq(other: Self): Boolean = !self.eq(other)
+
+extension [Self: Collection](self: Self)
+  def elementsEqual[T: Collection { type Element = Self.Element } ](other: T): Boolean =
+    ???

tests/pos/hylolib/AnyCollection.scala

@@ -19,7 +19,7 @@ object AnyCollection {
     // and `anyValueIsValue` when the method is called on a collection of `Int`s. None of these
     // choices is even correct! Note also that the ambiguity is suppressed if the constructor of
     // `AnyValue` is declared with a context bound rather than an implicit parameter.
-    given b.Position is Value = b.positionIsValue
+    given b.Position is Value = b.Position
 
     def start(): AnyValue =
       AnyValue(base.startPosition)

tests/pos/hylolib/Collection.scala

@@ -2,16 +2,16 @@
 package hylo
 
 /** A collection of elements accessible by their position. */
-trait Collection {
+trait Collection:
   type Self
 
   /** The type of the elements in the collection. */
   type Element: Value
 
   /** The type of a position in the collection. */
-  type Position: Value as positionIsValue
+  type Position: Value
 
-  extension (self: Self) {
+  extension (self: Self)
 
     /** Returns `true` iff `self` is empty. */
     def isEmpty: Boolean =
@@ -70,35 +70,25 @@ trait Collection {
       */
     def isBefore(i: Position, j: Position): Boolean =
       val e = self.endPosition
-      if (i.eq(e)) {
-        false
-      } else if (j.eq(e)) {
-        true
-      } else {
-        def _isBefore(n: Position): Boolean =
-          if (n.eq(j)) {
-            true
-          } else if (n.eq(e)) {
-            false
-          } else {
-            _isBefore(self.positionAfter(n))
-          }
-        _isBefore(self.positionAfter(i))
-      }
-
-  }
-
-}
-
-extension [Self: Collection as s](self: Self) {
+      if i `eq` e then false
+      else if j `eq` e then true
+      else
+        def recur(n: Position): Boolean =
+          if n `eq` j then true
+          else if n `eq` e then false
+          else recur(self.positionAfter(n))
+        recur(self.positionAfter(i))
+end Collection
+
+extension [Self: Collection](self: Self) {
 
   /** Returns the first element of `self` along with a slice containing the suffix after this
     * element, or `None` if `self` is empty.
     *
     * @complexity
     *   O(1)
     */
-  def headAndTail: Option[(s.Element, Slice[Self])] =
+  def headAndTail: Option[(Self.Element, Slice[Self])] =
     if (self.isEmpty) {
       None
     } else {
@@ -113,9 +103,9 @@ extension [Self: Collection as s](self: Self) {
     * @complexity
     *   O(n) where n is the number of elements in `self`.
     */
-  def reduce[T](partialResult: T, combine: (T, s.Element) => T): T =
+  def reduce[T](partialResult: T, combine: (T, Self.Element) => T): T =
     val e = self.endPosition
-    def loop(p: s.Position, r: T): T =
+    def loop(p: Self.Position, r: T): T =
       if (p.eq(e)) {
         r
       } else {
@@ -132,9 +122,9 @@ extension [Self: Collection as s](self: Self) {
     * @complexity
     *   O(n) where n is the number of elements in `self`.
     */
-  def forEach(action: (s.Element) => Boolean): Boolean =
+  def forEach(action: (Self.Element) => Boolean): Boolean =
     val e = self.endPosition
-    def loop(p: s.Position): Boolean =
+    def loop(p: Self.Position): Boolean =
       if (p.eq(e)) {
         true
       } else if (!action(self.at(p))) {
@@ -149,7 +139,7 @@ extension [Self: Collection as s](self: Self) {
     * @complexity
     *   O(n) where n is the number of elements in `self`.
     */
-  def map[T: Value](transform: (s.Element) => T): HyArray[T] =
+  def map[T: Value](transform: (Self.Element) => T): HyArray[T] =
     self.reduce(
       HyArray[T](),
       (r, e) => r.append(transform(e), assumeUniqueness = true)
@@ -160,9 +150,9 @@ extension [Self: Collection as s](self: Self) {
     * @complexity
     *   O(n) where n is the number of elements in `self`.
     */
-  def filter(isIncluded: (s.Element) => Boolean): HyArray[s.Element] =
+  def filter(isIncluded: (Self.Element) => Boolean): HyArray[Self.Element] =
     self.reduce(
-      HyArray[s.Element](),
+      HyArray[Self.Element](),
       (r, e) => if (isIncluded(e)) then r.append(e, assumeUniqueness = true) else r
     )
 
@@ -171,15 +161,15 @@ extension [Self: Collection as s](self: Self) {
     * @complexity
     *   O(n) where n is the number of elements in `self`.
     */
-  def containsWhere(predicate: (s.Element) => Boolean): Boolean =
+  def containsWhere(predicate: (Self.Element) => Boolean): Boolean =
     self.firstPositionWhere(predicate) != None
 
   /** Returns `true` if all elements in `self` satisfy `predicate`.
     *
     * @complexity
     *   O(n) where n is the number of elements in `self`.
     */
-  def allSatisfy(predicate: (s.Element) => Boolean): Boolean =
+  def allSatisfy(predicate: (Self.Element) => Boolean): Boolean =
     self.firstPositionWhere(predicate) == None
 
   /** Returns the position of the first element of `self` satisfying `predicate`, or `None` if no
@@ -188,9 +178,9 @@ extension [Self: Collection as s](self: Self) {
     * @complexity
     *   O(n) where n is the number of elements in `self`.
     */
-  def firstPositionWhere(predicate: (s.Element) => Boolean): Option[s.Position] =
+  def firstPositionWhere(predicate: (Self.Element) => Boolean): Option[Self.Position] =
     val e = self.endPosition
-    def loop(p: s.Position): Option[s.Position] =
+    def loop(p: Self.Position): Option[Self.Position] =
       if (p.eq(e)) {
         None
       } else if (predicate(self.at(p))) {
@@ -205,7 +195,7 @@ extension [Self: Collection as s](self: Self) {
     * @complexity
     *   O(n) where n is the number of elements in `self`.
     */
-  def minElement(isLessThan: (s.Element, s.Element) => Boolean): Option[s.Element] =
+  def minElement(isLessThan: (Self.Element, Self.Element) => Boolean): Option[Self.Element] =
     self.leastElement(isLessThan)
 
   // NOTE: I can't find a reasonable way to call this method.
@@ -214,36 +204,36 @@ extension [Self: Collection as s](self: Self) {
     * @complexity
     *   O(n) where n is the number of elements in `self`.
     */
-  def minElement()(using s.Element is Comparable): Option[s.Element] =
+  def minElement()(using Self.Element is Comparable): Option[Self.Element] =
     self.minElement(isLessThan = _ `lt` _)
 
   /** Returns the maximum element in `self`, using `isGreaterThan` to compare elements.
     *
     * @complexity
     *   O(n) where n is the number of elements in `self`.
     */
-  def maxElement(isGreaterThan: (s.Element, s.Element) => Boolean): Option[s.Element] =
+  def maxElement(isGreaterThan: (Self.Element, Self.Element) => Boolean): Option[Self.Element] =
     self.leastElement(isGreaterThan)
 
   /** Returns the maximum element in `self`.
     *
     * @complexity
     *   O(n) where n is the number of elements in `self`.
     */
-  def maxElement()(using s.Element is Comparable): Option[s.Element] =
+  def maxElement()(using Self.Element is Comparable): Option[Self.Element] =
     self.maxElement(isGreaterThan = _ `gt` _)
 
   /** Returns the maximum element in `self`, using `isOrderedBefore` to compare elements.
     *
     * @complexity
     *   O(n) where n is the number of elements in `self`.
     */
-  def leastElement(isOrderedBefore: (s.Element, s.Element) => Boolean): Option[s.Element] =
+  def leastElement(isOrderedBefore: (Self.Element, Self.Element) => Boolean): Option[Self.Element] =
     if (self.isEmpty) {
       None
     } else {
       val e = self.endPosition
-      def _least(p: s.Position, least: s.Element): s.Element =
+      def _least(p: Self.Position, least: Self.Element): Self.Element =
         if (p.eq(e)) {
           least
         } else {
@@ -258,22 +248,18 @@ extension [Self: Collection as s](self: Self) {
 
 }
 
-extension [Self: Collection as s](self: Self)(
-    using s.Element is Value
-) {
+extension [Self: Collection](self: Self)
 
   /** Returns `true` if `self` contains the same elements as `other`, in the same order. */
-  def elementsEqual[T](using o: T is Collection { type Element = s.Element })(other: T): Boolean =
-    def loop(i: s.Position, j: o.Position): Boolean =
-      if (i `eq` self.endPosition) {
+  def elementsEqual[T: Collection { type Element = Self.Element } ](other: T): Boolean =
+    def loop(i: Self.Position, j: T.Position): Boolean =
+      if i `eq` self.endPosition then
         j `eq` other.endPosition
-      } else if (j `eq` other.endPosition) {
+      else if j `eq` other.endPosition then
         false
-      } else if (self.at(i) `neq` other.at(j)) {
+      else if self.at(i) `neq` other.at(j)then
         false
-      } else {
+      else
         loop(self.positionAfter(i), other.positionAfter(j))
-      }
     loop(self.startPosition, other.startPosition)
 
-}