Scala Version bump to 3.6.2-RC2.

Scala 3.6.x regularizes many of the syntax changes for given and type classes that we are already writing code for. This version bump means we get better compiler support and can stop flagging the library as experimental.

Author: Mikael Vejdemo-Johansson

build.sbt

@@ -1,7 +1,7 @@
 name := "TDA4j"
 organization := "org.appliedtopology"
 version := "0.1.0-alpha"
-scalaVersion := "3.5.0"
+scalaVersion := "3.6.2-RC2"
 
 versionScheme := Some("semver-spec")
 
@@ -37,7 +37,7 @@ lazy val root = (project in file("."))
   )
   .settings(
     // these options make 3.5.0 use the given resolution algorithms planned for 3.7.x.
-    scalacOptions ++= List("-source:future", "-language:experimental.modularity"),
+    scalacOptions ++= List("-source:future"),
     Compile / paradoxMaterialTheme := {
       ParadoxMaterialTheme()
     },

src/main/scala/org/appliedtopology/tda4j/Barcode.scala

@@ -28,9 +28,7 @@ case class ClosedEndpoint[FiltrationT: Ordering](val value: FiltrationT) extends
   override val isFinite = true
 
 import math.Ordered.orderingToOrdered
-given [FiltrationT](using
-  ord: Ordering[FiltrationT]
-): Ordering[BarcodeEndpoint[FiltrationT]] with
+given [FiltrationT : Ordering as ord] => Ordering[BarcodeEndpoint[FiltrationT]]:
   def compare(
     x: BarcodeEndpoint[FiltrationT],
     y: BarcodeEndpoint[FiltrationT]
@@ -156,7 +154,7 @@ class BarcodeContext[FiltrationT: Ordering]():
   def dim(d: Int)(ba: BarAssembly) =
     new PersistenceBar[FiltrationT, Nothing](d, ba.lower, ba.upper)
 
-class Barcode[FiltrationT: Ordering: Numeric, AnnotationT]:
+class Barcode[FiltrationT: {Ordering, Numeric}, AnnotationT]:
   def isMap(
     source: List[PersistenceBar[FiltrationT, AnnotationT]],
     target: List[PersistenceBar[FiltrationT, AnnotationT]],

src/main/scala/org/appliedtopology/tda4j/Chain.scala

@@ -110,7 +110,7 @@ object Chain {
                                                         ): Chain[CellT, CoefficientT] =
     new Chain(mutable.PriorityQueue.from(cs)(using Ordering.by[(CellT, CoefficientT), CellT](_._1)(using ord.reverse)))
 
-  given chain_is_ordered_basis[CellT : Ordering, CoefficientT: Field as fld] : (Chain[CellT, CoefficientT] is OrderedBasis[CellT, CoefficientT]) with {
+  given chain_is_ordered_basis: [CellT : Ordering, CoefficientT: Field as fld] => (Chain[CellT, CoefficientT] is OrderedBasis[CellT, CoefficientT]):
     extension (self: Self)
       def leadingTerm: (Option[CellT], CoefficientT) = {
         self.collapseHead()
@@ -119,12 +119,12 @@ object Chain {
         }
           .apply(self.entries.headOption.unzip)
       }
-  }
+
 
   @tailrec
   final def reduceBy[CellT : Ordering, CoefficientT : Field](z : Chain[CellT, CoefficientT],
                basis: mutable.Map[CellT, Chain[CellT, CoefficientT]],
-               reductionLog: Chain[CellT, CoefficientT] = Chain()
+               reductionLog: Chain[CellT, CoefficientT] // want to have a default empty here?
               ): (Chain[CellT, CoefficientT], Chain[CellT, CoefficientT]) =
       z.leadingCell match {
         case None => (z, reductionLog)

src/main/scala/org/appliedtopology/tda4j/Homology.scala

@@ -190,7 +190,7 @@ class SimplicialHomologyByDimensionContext[VertexT: Ordering, CoefficientT: Fiel
       val dEdge = edge.boundary
       // TODO is it worth it to have a more complex UnionFind that allows us to get the entire path along the MST?
       val (reduced, reductionLog): (Chain[Simplex[VertexT], CoefficientT], Chain[Simplex[VertexT], CoefficientT]) =
-        Chain.reduceBy(dEdge, boundaries)
+        Chain.reduceBy(dEdge, boundaries, Chain.empty)
       val fr = summon[CoefficientT is Field]
       val coboundary: Chain[Simplex[VertexT], CoefficientT] =
         reductionLog.items.foldRight(fr.negate(fr.one) ⊠ Chain(edge)) { (item, acc) =>
@@ -211,7 +211,7 @@ class SimplicialHomologyByDimensionContext[VertexT: Ordering, CoefficientT: Fiel
         val fr = summon[CoefficientT is Field]
         val sigma = currentIterator.next()
         val dsigma: Chain[Simplex[VertexT], CoefficientT] = sigma.boundary
-        val (dsigmaReduced, reduction) = Chain.reduceBy(dsigma, boundaries)
+        val (dsigmaReduced, reduction) = Chain.reduceBy(dsigma, boundaries, Chain.empty)
         val coboundary = reduction.items.foldRight(fr.negate(fr.one) ⊠ Chain(sigma)) { (next, acc) =>
           val (spx, coeff) = next
           if coboundaries.contains(spx) then acc + coeff ⊠ coboundaries(spx)
@@ -227,7 +227,7 @@ class SimplicialHomologyByDimensionContext[VertexT: Ordering, CoefficientT: Fiel
           boundariesBornBy(dsigmaReduced.leadingCell.get) = sigma
           coboundaries(dsigmaReduced.leadingCell.get) = coboundary
 
-          val (_, cycleBasis) = Chain.reduceBy(dsigmaReduced, cycles)
+          val (_, cycleBasis) = Chain.reduceBy(dsigmaReduced, cycles, Chain.empty)
           val representativeCycle: Chain[Simplex[VertexT], CoefficientT] = cycleBasis.leadingCell match
             case None       => Chain()
             case Some(cell) => cycles(cell)

src/main/scala/org/appliedtopology/tda4j/Simplex.scala

@@ -40,5 +40,5 @@ def Simplex_is_OrderedCell[VertexT](using vtxOrd : Ordering[VertexT])(setOrderin
         )
     }
   }
-given default_Simplex_is_OrderedCell[VertexT : Ordering] : (Simplex[VertexT] is OrderedCell) =
+given default_Simplex_is_OrderedCell: [VertexT : Ordering] => (Simplex[VertexT] is OrderedCell) =
   Simplex_is_OrderedCell[VertexT]()

src/main/scala/org/appliedtopology/tda4j/SimplexStream.scala

@@ -36,7 +36,7 @@ given LongIsFilterable: Filterable[Long] = new Filterable[Long] {
   val largest = Long.MaxValue
 }
 
-trait Filtration[CellT: Cell, FiltrationT: Ordering: Filterable] extends Filterable[FiltrationT] {
+trait Filtration[CellT: Cell, FiltrationT: {Ordering, Filterable}] extends Filterable[FiltrationT] {
   def filtrationValue: PartialFunction[CellT, FiltrationT]
 }
 
@@ -60,7 +60,7 @@ trait CellStream[CellT: Cell, FiltrationT: Ordering] extends Filtration[CellT, F
   *   We may want to change this to inherit instead from `IterableOnce[Simplex[VertexT]]`, so that a lazy computed
   *   simplex stream can be created and fit in the type hierarchy.
   */
-trait SimplexStream[VertexT: Ordering, FiltrationT: Ordering: Filterable]
+trait SimplexStream[VertexT: Ordering, FiltrationT: {Ordering, Filterable}]
     extends CellStream[Simplex[VertexT], FiltrationT] {
   val filterable: Filterable[FiltrationT] = summon[Filterable[FiltrationT]]
   export filterable.{largest, smallest}
@@ -110,7 +110,7 @@ class ExplicitStream[VertexT: Ordering, FiltrationT](
   def length: Int = simplices.length
 }
 
-given [FiltrationT: Filterable]: Option[Filterable[FiltrationT]] =
+given [FiltrationT: Filterable] => Option[Filterable[FiltrationT]] =
   Some(summon[Filterable[FiltrationT]])
 
 class ExplicitStreamBuilder[VertexT: Ordering, FiltrationT](using