chore: update scala to 3.6.4 (#1091)

Fixes problem from
scala/scala3#22661 (comment)

Also I have got new compiler warnings that inner (inside `def`) types
`cannot be checked at runtime because it's a local class`, so I moved It
to internal object.

Author: road21

build.sbt

@@ -5,7 +5,7 @@ import org.typelevel.scalacoptions.ScalacOptions
 import org.typelevel.scalacoptions.ScalaVersion
 import sbtdynver.DynVerPlugin.autoImport.*
 
-val scala3Version   = "3.6.2"
+val scala3Version   = "3.6.4"
 val scala212Version = "2.12.20"
 val scala213Version = "2.13.15"
 

kyo-data/shared/src/main/scala/kyo/Record.scala

@@ -293,10 +293,12 @@ object Record:
 end Record
 
 object AsFieldsInternal:
-    private type HasAsField[Field] =
+    private type HasAsField[Field] <: AsField[?, ?] =
         Field match
             case name ~ value => AsField[name, value]
 
     inline def summonAsField[Fields](using ev: TypeIntersection[Fields]): Set[Field[?, ?]] =
-        TypeIntersection.summonAll[Fields, HasAsField].map(Record.AsField.toField).toSet
+        TypeIntersection.summonAll[Fields, HasAsField].map {
+            case a: AsField[?, ?] => Record.AsField.toField(a)
+        }.toSet
 end AsFieldsInternal

kyo-prelude/shared/src/main/scala/kyo/Batch.scala

@@ -1,6 +1,8 @@
 package kyo
 
 import Batch.internal.*
+import Batch.internal.Pending.Expanded
+import Batch.internal.Pending.ToExpand
 import kyo.Tag
 import kyo.kernel.*
 
@@ -102,54 +104,46 @@ object Batch:
       *   A sequence of results from executing the batched operations
       */
     def run[A: Flat, S](v: A < (Batch & S))(using Frame): Chunk[A] < S =
-
-        type SourceAny = Source[Any, Any, S]
-        type ContAny   = Any < (Batch & S) => (ToExpand | Expanded | A) < (Batch & S)
-
-        abstract class Pending
-        case class ToExpand(op: Seq[Any], cont: ContAny)                  extends Pending
-        case class Expanded(value: Any, source: SourceAny, cont: ContAny) extends Pending
-
         // An item can be a final value (`A`),
         // a sequence from `Batch.eval` (`ToExpand`),
         // or a call to a source (`Expanded`).
-        type Item = A | ToExpand | Expanded
+        type Item = A | ToExpand[A, S] | Expanded[A, S]
 
         // Transforms effect suspensions into an item.
         // Captures the continuation in the `Item` objects for `ToExpand` and `Expanded` cases.
         def capture(v: Item < (Batch & S)): Item < S =
             ArrowEffect.handle(Tag[Batch], v) {
                 [C] =>
                     (input, cont) =>
-                        val contAny = cont.asInstanceOf[ContAny]
+                        val contAny = cont.asInstanceOf[ContAny[A, S]]
                         input match
-                            case Call(v, source) => Expanded(v, source.asInstanceOf[SourceAny], contAny)
+                            case Call(v, source) => Expanded(v, source.asInstanceOf[SourceAny[S]], contAny)
                             case Eval(v)         => ToExpand(v, contAny)
             }
 
         // Expands any `Batch.eval` calls, capturing items for each element in the sequence.
         // Returns a `Chunk[Chunk[A]]` to reduce `map` calls.
         def expand(items: Chunk[Item]): Chunk[Chunk[Item]] < S =
             Kyo.foreach(items) {
-                case ToExpand(seq: Seq[Any], cont) =>
+                case ToExpand[A @unchecked, S @unchecked](seq: Seq[Any], cont) =>
                     Kyo.foreach(seq)(v => capture(cont(v)))
                 case item => Chunk(item)
             }
 
         // Groups all source calls (`Expanded`), calls their source functions, and reassembles the results.
         // Returns a `Chunk[Chunk[A]]` to reduce `map` calls.
         def flush(items: Chunk[Item]): Chunk[Chunk[Item]] < S =
-            val pending: Map[SourceAny | Unit, Seq[Item]] =
+            val pending: Map[SourceAny[S] | Unit, Seq[Item]] =
                 items.groupBy {
-                    case Expanded(_, source, _) => source
-                    case _                      => () // Used as a placeholder for items that aren't source calls
+                    case (Expanded[A @unchecked, S @unchecked](_, source, _)) => source
+                    case _ => () // Used as a placeholder for items that aren't source calls
                 }
             Kyo.foreach(pending.toSeq) { tuple =>
                 (tuple: @unchecked) match
                     case (_: Unit, items) =>
                         // No need for flushing
                         Chunk.from(items)
-                    case (source: SourceAny, items: Seq[Expanded] @unchecked) =>
+                    case (source: SourceAny[S], items: Seq[Expanded[A, S]] @unchecked) =>
                         // Only request distinct items from the source
                         source(items.map(_.value).distinct).map { results =>
                             // Reassemble the results by iterating on the original collection
@@ -163,13 +157,13 @@ object Batch:
 
         // The main evaluation loop that expands and flushes items until all values are final.
         def loop(items: Chunk[Item]): Chunk[A] < S =
-            if !items.exists((_: @unchecked).isInstanceOf[Pending]) then
+            if !items.exists((_: @unchecked).isInstanceOf[Pending[A, S]]) then
                 // All values are final, done
                 items.asInstanceOf[Chunk[A]]
             else
                 // The code repetition in the branches is a performance optimization to reduce
                 // `map` calls.
-                if items.exists((_: @unchecked).isInstanceOf[ToExpand]) then
+                if items.exists((_: @unchecked).isInstanceOf[ToExpand[A, S]]) then
                     // Expand `Batch.eval` calls if present
                     expand(items).map { expanded =>
                         flush(expanded.flattenChunk)
@@ -185,10 +179,16 @@ object Batch:
 
     object internal:
         type Source[A, B, S] = Seq[A] => (A => B < S) < S
+        type SourceAny[S]    = Source[Any, Any, S]
 
         sealed trait Op[A]
         case class Eval[A](seq: Seq[A])                         extends Op[A]
         case class Call[A, B, S](v: A, source: Source[A, B, S]) extends Op[B < (Batch & S)]
-    end internal
 
+        enum Pending[A, S]:
+            case ToExpand(op: Seq[Any], cont: ContAny[A, S])
+            case Expanded(value: Any, source: SourceAny[S], cont: ContAny[A, S])
+
+        type ContAny[A, S] = Any < (Batch & S) => (ToExpand[A, S] | Expanded[A, S] | A) < (Batch & S)
+    end internal
 end Batch