text: Research platform for new language concepts and compiler technologies for Scala.
  I was surprised to see this behavior
  scala> Option(1) == Option(2) 1 |Option(1) == Option(2) |^^^^^^^^^^^^^^^^^^^^^^ |Values of types Option[Int] and Option[Int] cannot be compared with == or != scala> Vector(1) == List(2) val res3: Boolean = false
  Why is there a default value for
  collection.Seq[T] but not
  Option[T]?
  ci.yamlon the Windows runner : does it matter if I split the runner command
  sbt ";sjsJUnitTests/test ;sjsCompilerTests/test"in two steps, i.e.
  sbt ";sjsJUnitTests/test"and then
  "sbt ;sjsCompilerTests/test"? PS: I have memory issues when running my Actions on my GitHub-hosted Windows runner (2 cpus + 8 GB versus 4 cpus + 24 GB at EPFL)
  Eqlin MUnit scalameta/munit#225 I think it would be really nice to be able to use multiversal equality for cases like this
  @smarter Fair enough, I opened
  I agree it would not scale to add
  Option[T] instances to the
  Eql object, a better approach would be to remove all of the default instances to give users 100% control over what types are safe to compare with each other. I am concerned this new language feature won't gain widespread adoption in its current form.
  final case class Universe() { case class Needle() def findNeedle(n: Needle) = n } // Doesn't compile def find1[U <: Universe with Singleton](u: U, n: U#Needle) = { u.findNeedle(n) } // Compiles def find2[U <: Universe with Singleton](u: U)(n: u.Needle) = { u.findNeedle(n) }
  find1not compile?
  final case class Universe() { val needle = Needle() case class Needle() { def combine(other: Needle): Needle = ??? } def findNeedle(n: Needle) = n } def combine[U <: Universe with Singleton](n1: U#Needle, n2: U#Needle) = { n1.combine(n2) }
  n1doesn't have
  Needlesince it is
  Needle
  def combine[U <: Universe, N <: U#Needle](n1: N, n2: N)maybe
  N <: Universe#Needle
  Universeand I'd like a method aware of that fact, able to operate on these types and return
  U#Somethingwithout needing to give it
  U.
  Is there any particular reason why this compiles
  object ChainedConversions1 { given implicitLength as Conversion[String, Int] = _.length given implicitLengths[A](using ev: Conversion[A, Int]) as Conversion[Seq[A], Seq[Int]] = _.map(ev) val strings: Seq[String] = Seq("", "a", "xyz") val lengths: Seq[Int] = strings }
  but this doesn't
  object ChainedConversions2 { implicit val implicitLength: Conversion[String, Int] = _.length implicit def implicitLengths[A](implicit ev: Conversion[A, Int]): Conversion[Seq[A], Seq[Int]] = _.map(ev) val strings: Seq[String] = Seq("", "a", "xyz") val lengths: Seq[Int] = strings }
  ?
  Main point being I have multiple types belonging to a single
  Universeand I'd like a method aware of that fact, able to operate on these types and return
  U#Somethingwithout needing to give it
  U.
  There is no good approach in Dotty if you need to bundle multiple type members. You can only resort to restating multiple type constructor parameters, like
  // Scala 2 trait Space[D <: Space[D]] { type Point <: PointLike type HyperCube <: HyperCubeLike } def foo[D <: Space[D]](p: D#Point, c: D#HyperCube) = ???
  // Scala 3 trait Space[P, H] def foo[P <: PointLike, H <: HyperCubeLike](p: P, c: H) = ???
  but as soon as these types need to be matched to each other, you know need an instance of
  Space:
  def foo[P <: PointLike, H <: HyperCubeLike](p: P, c: H)(implicit space: Space[P, H]) = ???