Merge pull request #4784 from typelevel/update/scalafmt-core-3.9.10

satorg · web-flow · commit 0d71d050b12b · 2025-10-25T11:00:12.000-07:00
Update scalafmt-core to 3.9.10
diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
@@ -21,3 +21,6 @@ b4d207e9fa9f1463f0827fe20101e7901fecf820
 
 # Fix errors under Scala 3.6.3
 fab4479a6b2975e5243565671a3a33a24469662d
+
+# Scala Steward: Reformat with scalafmt 3.9.10
+cdc7d21b5cca65d410b89d480b3ccf19594946c1
diff --git a/.scalafmt.conf b/.scalafmt.conf
@@ -1,4 +1,4 @@
-version=3.9.4
+version=3.9.10
 align.openParenCallSite = true
 align.openParenDefnSite = true
 maxColumn = 120
diff --git a/alleycats-core/src/main/scala/alleycats/std/iterable.scala b/alleycats-core/src/main/scala/alleycats/std/iterable.scala
@@ -97,7 +97,7 @@ trait IterableInstances {
 
   private def toImIndexedSeq[A](fa: Iterable[A]): ImIndexedSeq[A] = fa match {
     case iseq: ImIndexedSeq[A] => iseq
-    case _ =>
+    case _                     =>
       val as = collection.mutable.ArrayBuffer[A]()
       as ++= fa
       wrapMutableIndexedSeq(as)
diff --git a/core/src/main/scala-2.12/cats/data/ChainCompanionCompat.scala b/core/src/main/scala-2.12/cats/data/ChainCompanionCompat.scala
@@ -58,7 +58,7 @@ private[data] trait ChainCompanionCompat {
     xs match {
       case s: immutable.Seq[A] => fromImmutableSeq(s) // pay O(1) not O(N) cost
       case s: Seq[A]           => fromMutableSeq(s)
-      case notSeq =>
+      case notSeq              =>
         fromImmutableSeq(notSeq.toVector) // toSeq could return a Stream, creating potential race conditions
     }
 }
diff --git a/core/src/main/scala-2.13+/cats/instances/arraySeq.scala b/core/src/main/scala-2.13+/cats/instances/arraySeq.scala
@@ -113,7 +113,7 @@ private[cats] object ArraySeqInstances {
       override def traverseVoid[G[_], A, B](fa: ArraySeq[A])(f: A => G[B])(implicit G: Applicative[G]): G[Unit] =
         G match {
           case x: StackSafeMonad[G] => Traverse.traverseVoidDirectly(fa)(f)(x)
-          case _ =>
+          case _                    =>
             foldRight(fa, Eval.now(G.unit)) { (a, acc) =>
               G.map2Eval(f(a), acc) { (_, _) =>
                 ()
diff --git a/core/src/main/scala/cats/Eval.scala b/core/src/main/scala/cats/Eval.scala
@@ -313,7 +313,7 @@ object Eval extends EvalInstances {
     def value: A =
       result match {
         case Some(a) => a
-        case None =>
+        case None    =>
           val a = evaluate(this)
           result = Some(a)
           a
diff --git a/core/src/main/scala/cats/TraverseFilter.scala b/core/src/main/scala/cats/TraverseFilter.scala
@@ -146,7 +146,7 @@ trait TraverseFilter[F[_]] extends FunctorFilter[F] {
       State { (distinct: IntMap[List[A]]) =>
         val ahash = H.hash(a)
         distinct.get(ahash) match {
-          case None => (distinct.updated(ahash, a :: Nil), Some(a))
+          case None           => (distinct.updated(ahash, a :: Nil), Some(a))
           case Some(existing) =>
             if (Traverse[List].contains_(existing, a))
               (distinct, None)
diff --git a/core/src/main/scala/cats/data/AndThen.scala b/core/src/main/scala/cats/data/AndThen.scala
@@ -110,7 +110,7 @@ sealed abstract class AndThen[-T, +R] extends (T => R) with Product with Seriali
     // technique implemented for `cats.effect.IO#map`
     g match {
       case atg: AndThen[A, T] => AndThen.andThen(atg, this)
-      case _ =>
+      case _                  =>
         this match {
           case Single(f, index) if index < fusionMaxStackDepth =>
             Single(f.compose(g), index + 1)
diff --git a/core/src/main/scala/cats/data/Chain.scala b/core/src/main/scala/cats/data/Chain.scala
@@ -600,7 +600,7 @@ sealed abstract class Chain[+A] extends ChainCompat[A] {
    */
   final def zipWithIndex: Chain[(A, Int)] =
     this match {
-      case Singleton(a) => Singleton((a, 0))
+      case Singleton(a)     => Singleton((a, 0))
       case a @ Append(_, _) =>
         Wrap(a.iterator.zipWithIndex.toVector)
       case Wrap(seq) => Wrap(seq.zipWithIndex)
@@ -724,7 +724,7 @@ sealed abstract class Chain[+A] extends ChainCompat[A] {
     @annotation.tailrec
     def loop[B <: A](h: Chain.NonEmpty[B], tail: List[Chain.NonEmpty[B]], acc: Chain[A]): Chain[A] =
       h match {
-        case Append(l, r) => loop(l, r :: tail, acc)
+        case Append(l, r)        => loop(l, r :: tail, acc)
         case sing @ Singleton(_) =>
           val nextAcc = sing.concat(acc)
           tail match {
@@ -1450,7 +1450,7 @@ sealed abstract private[data] class ChainInstances extends ChainInstances1 {
       override def traverseVoid[G[_], A, B](fa: Chain[A])(f: A => G[B])(implicit G: Applicative[G]): G[Unit] =
         G match {
           case x: StackSafeMonad[G] => Traverse.traverseVoidDirectly(fa.iterator)(f)(x)
-          case _ =>
+          case _                    =>
             @tailrec
             def go(fa: NonEmpty[A], rhs: Chain[A], acc: G[Unit]): G[Unit] =
               fa match {
@@ -1460,21 +1460,21 @@ sealed abstract private[data] class ChainInstances extends ChainInstances1 {
                   val va = Foldable[collection.immutable.Seq].traverseVoid(as)(f)
                   val acc1 = G.productL(acc)(va)
                   rhs match {
-                    case Empty => acc1
+                    case Empty           => acc1
                     case ne: NonEmpty[A] =>
                       go(ne, Empty, acc1)
                   }
                 case Singleton(a) =>
                   val acc1 = G.productL(acc)(f(a))
                   rhs match {
-                    case Empty => acc1
+                    case Empty           => acc1
                     case ne: NonEmpty[A] =>
                       go(ne, Empty, acc1)
                   }
               }
 
             fa match {
-              case Empty => G.unit
+              case Empty           => G.unit
               case ne: NonEmpty[A] =>
                 go(ne, Empty, G.unit)
             }
diff --git a/core/src/main/scala/cats/data/Ior.scala b/core/src/main/scala/cats/data/Ior.scala
@@ -802,11 +802,11 @@ sealed abstract class Ior[+A, +B] extends Product with Serializable {
 
   final def compare[AA >: A, BB >: B](that: AA Ior BB)(implicit AA: Order[AA], BB: Order[BB]): Int =
     (this, that) match {
-      case (Ior.Left(a1), Ior.Left(a2))   => AA.compare(a1, a2)
-      case (Ior.Left(_), _)               => -1
-      case (Ior.Right(b1), Ior.Right(b2)) => BB.compare(b1, b2)
-      case (Ior.Right(_), Ior.Left(_))    => 1
-      case (Ior.Right(_), Ior.Both(_, _)) => -1
+      case (Ior.Left(a1), Ior.Left(a2))         => AA.compare(a1, a2)
+      case (Ior.Left(_), _)                     => -1
+      case (Ior.Right(b1), Ior.Right(b2))       => BB.compare(b1, b2)
+      case (Ior.Right(_), Ior.Left(_))          => 1
+      case (Ior.Right(_), Ior.Both(_, _))       => -1
       case (Ior.Both(a1, b1), Ior.Both(a2, b2)) => {
         val r = AA.compare(a1, a2)
         if (r == 0) BB.compare(b1, b2) else r
@@ -891,7 +891,7 @@ sealed abstract private[data] class IorInstances extends IorInstances0 {
             case Ior.Right(Right(c))   => Ior.right(c)
             case Ior.Both(a, Right(c)) => Ior.both(a, c)
             case Ior.Right(Left(b))    => loop(fn(b))
-            case Ior.Both(a, Left(b)) =>
+            case Ior.Both(a, Left(b))  =>
               fn(b) match {
                 case Ior.Left(aa)    => Ior.left(Semigroup[A].combine(a, aa))
                 case Ior.Both(aa, x) => loop(Ior.both(Semigroup[A].combine(a, aa), x))
@@ -961,7 +961,7 @@ sealed abstract private[data] class IorInstances0 {
       override def mapAccumulate[S, B, C](init: S, fa: Ior[A, B])(f: (S, B) => (S, C)): (S, Ior[A, C]) =
         fa match {
           case l @ Ior.Left(_) => (init, l)
-          case Ior.Right(b) =>
+          case Ior.Right(b)    =>
             val (snext, c) = f(init, b)
             (snext, Ior.Right(c))
           case Ior.Both(a, b) =>
diff --git a/core/src/main/scala/cats/data/IorT.scala b/core/src/main/scala/cats/data/IorT.scala
@@ -118,7 +118,7 @@ final case class IorT[F[_], A, B](value: F[Ior[A, B]]) {
     IorT(F.flatMap(value) {
       case Ior.Left(a)      => f(a).value
       case r @ Ior.Right(_) => F.pure(r.asInstanceOf[Ior[C, BB]])
-      case Ior.Both(a, b) =>
+      case Ior.Both(a, b)   =>
         F.map(f(a).value) {
           case Ior.Left(c)     => Ior.Both(c, b)
           case Ior.Right(b1)   => Ior.Right(BB.combine(b, b1))
@@ -142,7 +142,7 @@ final case class IorT[F[_], A, B](value: F[Ior[A, B]]) {
     IorT(F.flatMap(value) {
       case l @ Ior.Left(_) => F.pure(l.asInstanceOf[Ior[AA, D]])
       case Ior.Right(b)    => f(b).value
-      case Ior.Both(a, b) =>
+      case Ior.Both(a, b)  =>
         F.map(f(b).value) {
           case Ior.Left(a1)    => Ior.Left(AA.combine(a, a1))
           case Ior.Right(d)    => Ior.Both(a, d)
diff --git a/core/src/main/scala/cats/data/NonEmptyList.scala b/core/src/main/scala/cats/data/NonEmptyList.scala
@@ -321,7 +321,7 @@ final case class NonEmptyList[+A](head: A, tail: List[A]) extends NonEmptyCollec
     val buf = ListBuffer.empty[B]
     @tailrec def consume(as: List[A]): List[B] =
       as match {
-        case Nil => buf.toList
+        case Nil     => buf.toList
         case a :: as =>
           buf += f(NonEmptyList(a, as))
           consume(as)
diff --git a/core/src/main/scala/cats/data/Validated.scala b/core/src/main/scala/cats/data/Validated.scala
@@ -235,7 +235,7 @@ sealed abstract class Validated[+E, +A] extends Product with Serializable {
   def findValid[EE >: E, AA >: A](that: => Validated[EE, AA])(implicit EE: Semigroup[EE]): Validated[EE, AA] =
     this match {
       case v @ Valid(_) => v
-      case Invalid(e) =>
+      case Invalid(e)   =>
         that match {
           case v @ Valid(_) => v
           case Invalid(ee)  => Invalid(EE.combine(e, ee))
@@ -885,7 +885,7 @@ sealed abstract private[data] class ValidatedInstances extends ValidatedInstance
       def combineK[B](x: Validated[A, B], y: Validated[A, B]): Validated[A, B] =
         x match {
           case v @ Valid(_) => v
-          case Invalid(ix) =>
+          case Invalid(ix)  =>
             y match {
               case Invalid(iy)  => Invalid(A.combine(ix, iy))
               case v @ Valid(_) => v
diff --git a/core/src/main/scala/cats/instances/list.scala b/core/src/main/scala/cats/instances/list.scala
@@ -123,7 +123,7 @@ trait ListInstances extends cats.kernel.instances.ListInstances {
         else
           G match {
             case x: StackSafeMonad[G] => x.map(Traverse.traverseDirectly[G, A, B](fa)(f)(x))(_.toList)
-            case _ =>
+            case _                    =>
               G.map(Chain.traverseViaChain {
                 val as = collection.mutable.ArrayBuffer[A]()
                 as ++= fa
@@ -216,7 +216,7 @@ trait ListInstances extends cats.kernel.instances.ListInstances {
       @tailrec
       override def get[A](fa: List[A])(idx: Long): Option[A] =
         fa match {
-          case Nil => None
+          case Nil       => None
           case h :: tail =>
             if (idx < 0) None
             else if (idx == 0) Some(h)
@@ -234,7 +234,7 @@ trait ListInstances extends cats.kernel.instances.ListInstances {
       override def foldM[G[_], A, B](fa: List[A], z: B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B] = {
         def step(in: (List[A], B)): G[Either[(List[A], B), B]] =
           in match {
-            case (Nil, b) => G.pure(Right(b))
+            case (Nil, b)       => G.pure(Right(b))
             case (a :: tail, b) =>
               G.map(f(b, a)) { bnext =>
                 Left((tail, bnext))
@@ -321,7 +321,7 @@ private[instances] trait ListInstancesBinCompat0 {
       else
         G match {
           case x: StackSafeMonad[G] => x.map(TraverseFilter.traverseFilterDirectly(fa)(f)(x))(_.toList)
-          case _ =>
+          case _                    =>
             G.map(Chain.traverseFilterViaChain {
               val as = collection.mutable.ArrayBuffer[A]()
               as ++= fa
diff --git a/core/src/main/scala/cats/instances/option.scala b/core/src/main/scala/cats/instances/option.scala
@@ -125,7 +125,7 @@ trait OptionInstances extends cats.kernel.instances.OptionInstances {
 
       override def map2Eval[A, B, Z](fa: Option[A], fb: Eval[Option[B]])(f: (A, B) => Z): Eval[Option[Z]] =
         fa match {
-          case None => Now(None)
+          case None    => Now(None)
           case Some(a) =>
             fb.map {
               case Some(b) => Some(f(a, b))
diff --git a/core/src/main/scala/cats/instances/queue.scala b/core/src/main/scala/cats/instances/queue.scala
@@ -136,7 +136,7 @@ trait QueueInstances extends cats.kernel.instances.QueueInstances {
       override def traverseVoid[G[_], A, B](fa: Queue[A])(f: A => G[B])(implicit G: Applicative[G]): G[Unit] =
         G match {
           case x: StackSafeMonad[G] => Traverse.traverseVoidDirectly(fa)(f)(x)
-          case _ =>
+          case _                    =>
             foldRight(fa, Eval.now(G.unit)) { (a, acc) =>
               G.map2Eval(f(a), acc) { (_, _) =>
                 ()
diff --git a/core/src/main/scala/cats/instances/seq.scala b/core/src/main/scala/cats/instances/seq.scala
@@ -96,7 +96,7 @@ trait SeqInstances extends cats.kernel.instances.SeqInstances {
         @tailrec
         def loop(): Unit =
           state match {
-            case Nil => ()
+            case Nil                    => ()
             case h :: tail if h.isEmpty =>
               state = tail
               loop()
@@ -136,7 +136,7 @@ trait SeqInstances extends cats.kernel.instances.SeqInstances {
       override def traverseVoid[G[_], A, B](fa: Seq[A])(f: A => G[B])(implicit G: Applicative[G]): G[Unit] =
         G match {
           case x: StackSafeMonad[G] => Traverse.traverseVoidDirectly(fa)(f)(x)
-          case _ =>
+          case _                    =>
             foldRight(fa, Eval.now(G.unit)) { (a, acc) =>
               G.map2Eval(f(a), acc) { (_, _) =>
                 ()
@@ -210,7 +210,7 @@ trait SeqInstances extends cats.kernel.instances.SeqInstances {
     def traverseFilter[G[_], A, B](fa: Seq[A])(f: (A) => G[Option[B]])(implicit G: Applicative[G]): G[Seq[B]] =
       G match {
         case x: StackSafeMonad[G] => x.map(TraverseFilter.traverseFilterDirectly(fa)(f)(x))(_.toVector)
-        case _ =>
+        case _                    =>
           G.map(Chain.traverseFilterViaChain(fa.toIndexedSeq)(f))(_.toVector)
       }
 
diff --git a/core/src/main/scala/cats/instances/vector.scala b/core/src/main/scala/cats/instances/vector.scala
@@ -95,7 +95,7 @@ trait VectorInstances extends cats.kernel.instances.VectorInstances {
         @tailrec
         def loop(): Unit =
           state match {
-            case Nil => ()
+            case Nil                    => ()
             case h :: tail if h.isEmpty =>
               state = tail
               loop()
@@ -272,7 +272,7 @@ private[instances] trait VectorInstancesBinCompat0 {
     def traverseFilter[G[_], A, B](fa: Vector[A])(f: (A) => G[Option[B]])(implicit G: Applicative[G]): G[Vector[B]] =
       G match {
         case x: StackSafeMonad[G] => x.map(TraverseFilter.traverseFilterDirectly(fa)(f)(x))(_.toVector)
-        case _ =>
+        case _                    =>
           G.map(Chain.traverseFilterViaChain(fa)(f))(_.toVector)
       }
 
diff --git a/core/src/main/scala/cats/syntax/either.scala b/core/src/main/scala/cats/syntax/either.scala
@@ -316,7 +316,7 @@ final class EitherOps[A, B](private val eab: Either[A, B]) extends AnyVal {
   final def combine[AA >: A, BB >: B](that: Either[AA, BB])(implicit BB: Semigroup[BB]): Either[AA, BB] =
     eab match {
       case left @ Left(_) => left
-      case Right(b1) =>
+      case Right(b1)      =>
         that match {
           case left @ Left(_) => left
           case Right(b2)      => Right(BB.combine(b1, b2))
diff --git a/free/src/main/scala/cats/free/Free.scala b/free/src/main/scala/cats/free/Free.scala
@@ -84,8 +84,8 @@ sealed abstract class Free[S[_], A] extends Product with Serializable with FreeF
   @tailrec
   final def resume(implicit S: Functor[S]): Either[S[Free[S, A]], A] =
     this match {
-      case Pure(a)    => Right(a)
-      case Suspend(t) => Left(S.map(t)(Pure(_)))
+      case Pure(a)          => Right(a)
+      case Suspend(t)       => Left(S.map(t)(Pure(_)))
       case FlatMapped(c, f) =>
         c match {
           case Pure(a)          => f(a).resume
diff --git a/free/src/main/scala/cats/free/FreeApplicative.scala b/free/src/main/scala/cats/free/FreeApplicative.scala
@@ -53,7 +53,7 @@ sealed abstract class FreeApplicative[F[_], A] extends Product with Serializable
   final def map2[B, C](fb: FA[F, B])(f: (A, B) => C): FA[F, C] =
     this match {
       case Pure(a) => fb.map(f(a, _))
-      case _ =>
+      case _       =>
         fb match {
           case Pure(b) => Ap(Pure(f(_: A, b)), this)
           case _       => Ap(Ap(Pure((a: A) => (b: B) => f(a, b)), this), fb)
diff --git a/free/src/main/scala/cats/free/FreeT.scala b/free/src/main/scala/cats/free/FreeT.scala
@@ -125,7 +125,7 @@ sealed abstract class FreeT[S[_], M[_], A] extends Product with Serializable {
   def resume(implicit S: Functor[S], M: Monad[M]): M[Either[S[FreeT[S, M, A]], A]] = {
     def go(ft: FreeT[S, M, A]): M[Either[FreeT[S, M, A], Either[S[FreeT[S, M, A]], A]]] =
       ft match {
-        case Suspend(f) => M.map(f)(as => Right(as.left.map(S.map(_)(pure(_)))))
+        case Suspend(f)            => M.map(f)(as => Right(as.left.map(S.map(_)(pure(_)))))
         case g1 @ FlatMapped(_, _) =>
           g1.a match {
             case Suspend(m1) =>
diff --git a/kernel/src/main/scala/cats/kernel/instances/EitherInstances.scala b/kernel/src/main/scala/cats/kernel/instances/EitherInstances.scala
@@ -48,7 +48,7 @@ trait EitherInstances extends EitherInstances0 {
       def combine(x: Either[A, B], y: Either[A, B]): Either[A, B] =
         x match {
           case left @ Left(_) => left
-          case Right(xx) =>
+          case Right(xx)      =>
             y match {
               case left @ Left(_) => left
               case Right(yy)      => Right(B.combine(xx, yy))
@@ -63,7 +63,7 @@ private[instances] trait EitherInstances0 extends EitherInstances1 {
     (x, y) =>
       x match {
         case left @ Left(_) => left
-        case Right(xx) =>
+        case Right(xx)      =>
           y match {
             case left @ Left(_) => left
             case Right(yy)      => Right(B.combine(xx, yy))
diff --git a/kernel/src/main/scala/cats/kernel/instances/ListInstances.scala b/kernel/src/main/scala/cats/kernel/instances/ListInstances.scala
@@ -55,7 +55,7 @@ class ListOrder[A](implicit ev: Order[A]) extends Order[List[A]] {
           if (ys.isEmpty) 0 else -1
         case x :: xs =>
           ys match {
-            case Nil => 1
+            case Nil     => 1
             case y :: ys =>
               val n = ev.compare(x, y)
               if (n != 0) n else loop(xs, ys)
@@ -73,7 +73,7 @@ class ListPartialOrder[A](implicit ev: PartialOrder[A]) extends PartialOrder[Lis
           if (ys.isEmpty) 0.0 else -1.0
         case x :: xs =>
           ys match {
-            case Nil => 1.0
+            case Nil     => 1.0
             case y :: ys =>
               val n = ev.partialCompare(x, y)
               if (n != 0.0) n else loop(xs, ys)
diff --git a/kernel/src/main/scala/cats/kernel/instances/OptionInstances.scala b/kernel/src/main/scala/cats/kernel/instances/OptionInstances.scala
@@ -83,7 +83,7 @@ class OptionHash[A](implicit A: Hash[A]) extends OptionEq[A]()(A) with Hash[Opti
 class OptionEq[A](implicit A: Eq[A]) extends Eq[Option[A]] {
   def eqv(x: Option[A], y: Option[A]): Boolean =
     x match {
-      case None => y.isEmpty
+      case None    => y.isEmpty
       case Some(a) =>
         y match {
           case None    => false
@@ -96,7 +96,7 @@ class OptionMonoid[A](implicit A: Semigroup[A]) extends Monoid[Option[A]] {
   def empty: Option[A] = None
   def combine(x: Option[A], y: Option[A]): Option[A] =
     x match {
-      case None => y
+      case None    => y
       case Some(a) =>
         y match {
           case None    => x
diff --git a/laws/src/main/scala/cats/laws/AlignLaws.scala b/laws/src/main/scala/cats/laws/AlignLaws.scala
@@ -50,7 +50,7 @@ trait AlignLaws[F[_]] {
 
   private def assoc[A, B, C](x: Ior[A, Ior[B, C]]): Ior[Ior[A, B], C] =
     x match {
-      case Left(a) => Left(Left(a))
+      case Left(a)   => Left(Left(a))
       case Right(bc) =>
         bc match {
           case Left(b)    => Left(Right(b))
diff --git a/tests/shared/src/test/scala/cats/tests/AndThenSuite.scala b/tests/shared/src/test/scala/cats/tests/AndThenSuite.scala
diff --git a/tests/shared/src/test/scala/cats/tests/ApplicativeSuite.scala b/tests/shared/src/test/scala/cats/tests/ApplicativeSuite.scala
diff --git a/tests/shared/src/test/scala/cats/tests/FoldableSuite.scala b/tests/shared/src/test/scala/cats/tests/FoldableSuite.scala
diff --git a/tests/shared/src/test/scala/cats/tests/ParallelSuite.scala b/tests/shared/src/test/scala/cats/tests/ParallelSuite.scala

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-version=3.9.4`
	`1`	`+version=3.9.10`
`2`	`2`	`align.openParenCallSite = true`
`3`	`3`	`align.openParenDefnSite = true`
`4`	`4`	`maxColumn = 120`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ private[data] trait ChainCompanionCompat {`
`58`	`58`	`xs match {`
`59`	`59`	`case s: immutable.Seq[A] => fromImmutableSeq(s) // pay O(1) not O(N) cost`
`60`	`60`	`case s: Seq[A] => fromMutableSeq(s)`
`61`		`- case notSeq =>`
	`61`	`+ case notSeq =>`
`62`	`62`	`fromImmutableSeq(notSeq.toVector) // toSeq could return a Stream, creating potential race conditions`
`63`	`63`	`}`
`64`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -313,7 +313,7 @@ object Eval extends EvalInstances {`
`313`	`313`	`def value: A =`
`314`	`314`	`result match {`
`315`	`315`	`case Some(a) => a`
`316`		`- case None =>`
	`316`	`+ case None =>`
`317`	`317`	`val a = evaluate(this)`
`318`	`318`	`result = Some(a)`
`319`	`319`	`a`