Hylolib: Alternative, statically safe Slice design

Author: odersky

tests/pos/hylolib/AnyCollection.scala

@@ -48,16 +48,8 @@ given [T: Value] => AnyCollection[T] is Collection:
   type Position = AnyValue
 
   extension (self: AnyCollection[T])
-
-    def startPosition =
-      self._start()
-
-    def endPosition =
-      self._end()
-
-    def positionAfter(p: Position) =
-      self._after(p)
-
-    def at(p: Position) =
-      self._at(p)
+    def startPosition = self._start()
+    def endPosition = self._end()
+    def positionAfter(p: Position) = self._after(p)
+    def at(p: Position) = self._at(p)
 

tests/pos/hylolib/AnyValue.scala

@@ -61,13 +61,7 @@ object AnyValue {
 given AnyValue is Value:
 
   extension (self: AnyValue)
-
-    def copy(): AnyValue =
-      self.copy()
-
-    def eq(other: AnyValue): Boolean =
-      self `eq` other
-
-    def hashInto(hasher: Hasher): Hasher =
-      self.hashInto(hasher)
+    def copy(): AnyValue = self.copy()
+    def eq(other: AnyValue): Boolean = self `eq` other
+    def hashInto(hasher: Hasher): Hasher = self.hashInto(hasher)
 

tests/pos/hylolib/Collection.scala

@@ -78,6 +78,22 @@ trait Collection:
           else if n `eq` e then false
           else recur(self.positionAfter(n))
         recur(self.positionAfter(i))
+
+  class Slice2(val base: Self, val bounds: Range[Position]):
+
+    def isEmpty: Boolean =
+      bounds.lowerBound.eq(bounds.upperBound)
+
+    def startPosition: Position =
+      bounds.lowerBound
+
+    def endPosition: Position =
+      bounds.upperBound
+
+    def at(p: Position): Element =
+      base.at(p)
+  end Slice2
+
 end Collection
 
 extension [Self: Collection](self: Self)
@@ -97,6 +113,15 @@ extension [Self: Collection](self: Self)
       val t = Slice(self, Range(q, self.endPosition, (a, b) => (a `eq` b) || self.isBefore(a, b)))
       Some((self.at(p), t))
 
+  def headAndTail2: Option[(Self.Element, Self.Slice2)] =
+    if self.isEmpty then
+      None
+    else
+      val p = self.startPosition
+      val q = self.positionAfter(p)
+      val t = Self.Slice2(self, Range(q, self.endPosition, (a, b) => (a `eq` b) || self.isBefore(a, b)))
+      Some((self.at(p), t))
+
   /** Applies `combine` on `partialResult` and each element of `self`, in order.
     *
     * @complexity

tests/pos/hylolib/Slice.scala

@@ -2,8 +2,8 @@ package hylo
 
 /** A view into a collection. */
 final class Slice[Base: Collection](
-  tracked val base: Base,
-  tracked val bounds: Range[Base.Position]
+  val base: Base,
+  val bounds: Range[Base.Position]
 ) {
 
   /** Returns `true` iff `this` is empty. */
@@ -24,17 +24,40 @@ final class Slice[Base: Collection](
 
 }
 
-given [T: Collection as c] => Slice[T] is Collection:
+given [C: Collection] => Slice[C] is Collection:
 
-  type Element = c.Element
-  type Position = c.Position
+  type Element = C.Element
+  type Position = C.Position
 
-  extension (self: Slice[T])
+  extension (self: Slice[C])
 
-    def startPosition = self.bounds.lowerBound.asInstanceOf[Position] // NOTE: Ugly hack
+    def startPosition = self.bounds.lowerBound.asInstanceOf[Position]
+      // This is actually unsafe. We have:
+      //   self.bounds: Range(Slice[C].Base.Position)
+      // But the _value_ of Slice[C].Base is not necssarily this given, even
+      // though it is true that `type Slice[C].Base = C`. There might be multiple
+      // implementations of `Slice[C] is Collection` that define different `Position`
+      // types. So we cannot conclude that `Slice[C].Base.Position = this.Position`.
+      // To make this safe, we'd need some form of coherence, where we ensure that
+      // there is only one way to implement `Slice is Collection`.
+      //
+      // As an alternativem we can make Slice dependent on the original Collection
+      // _instance_ instead of the original Collection _type_. This design is
+      // realized by the Slice2 definitions. It works without casts.
 
     def endPosition = self.bounds.upperBound.asInstanceOf[Position]
 
     def positionAfter(p: Position) = self.base.positionAfter(p)
 
     def at(p: Position) = self.base.at(p)
+
+given [C: Collection] => C.Slice2 is Collection:
+  type Element = C.Element
+  type Position = C.Position
+
+  extension (self: C.Slice2)
+
+    def startPosition = self.bounds.lowerBound
+    def endPosition = self.bounds.upperBound
+    def positionAfter(p: Position) = self.base.positionAfter(p)
+    def at(p: Position) = self.base.at(p)