Administered by:
So... am I missing something, or am I breaking the compiler a little by overriding the `equals` method of a sum type?
https://scastie.scala-lang.org/nrinaudo/axeL5xlATteCz977XHh2lw/1
scastie.scala-lang.orgScastie - An interactive playground for Scala.//> using scala 3
//> using option -Xkind-projector:underscores
def assertEquals[A](observed: A, expected: A) = assert(observed == expected)
// - Boundary / Break -----------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------
// `boundary` sets a label, `break(a)` goes to that label and returns `a`.
object boundary:
final class Label[-A]
private final case class Break[A](value: A, label: Label[A])
extends RuntimeException(null, null, false, false)
def break[A](value: A)(using l: Label[A]): Nothing = throw Break(value, l)
inline def apply[A](inline body: Label[A] ?=> A): A =
val label = new Label[A]
try body(using label)
catch case Break(value, `label`) => value
// - Results --------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------
// Kind of like `Either`, but specifically meant for error handling.
enum Result[+E, +A]:
case Success(value: A)
case Failure(error: E)
// Syntactic sugar to lift values in `Result`.
extension [A](value: A)
def success[E]: Result[E, A] = Result.Success(value)
def failure[E]: Result[A, E] = Result.Failure(value)
// - Working with Results --------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------
// Type of things that can fail.
infix type failsWith[A, E] = boundary.Label[Result[E, Nothing]] ?=> A
object results:
// Forces evaluation `body`, wrapping the result in `Result.Success`.
// We know failures are encoded as `Failure` because of the type of
// the label we're carrying.
inline def apply[E, A](inline body: A failsWith E): Result[E, A] =
boundary:
Result.Success(body)
// Fails with the specified error.
def fail[E](error: E)(using boundary.Label[Result[E, Nothing]]): Nothing =
boundary.break(error.failure)
// De-references the specified result if a `Success`, or fails to the
// enclosing label.
extension [E, A](result: Result[E, A])
def ?(using boundary.Label[Result[E, Nothing]]): A =
result match
case Result.Success(a) => a
case Result.Failure(e) => boundary.break(Result.Failure(e))
// `fail` demonstration: removes the optional layer, failing on the first `None`.
def unwrap[A](as: List[Option[A]]): List[A] failsWith String =
as.map:
case Some(a) => a
case None => fail("found a None")
assertEquals(
observed = results(unwrap(List(Some(1), Some(2)))),
expected = List(1, 2).success
)
assertEquals(
observed = results(unwrap(List(Some(1), Some(2), None))),
expected = "found a None".failure
)
// `?` demonstration: sequence is quite a bit more pleasant implement that way, isn't it?
def sequence[A, E](as: List[Result[E, A]]): Result[E, List[A]] =
results:
as.map(_.?)
assertEquals(
observed = sequence(List(1.success, 2.success)),
expected = List(1, 2).success
)
assertEquals(
observed = sequence(List(1.success, 2.success, "some failure".failure)),
expected = "some failure".failure
)
@NicolasRinaudo It turns out many things go wrong when one tries to override 'equals' in dotty https://github.com/scala/scala3/discussions/17821
GitHubProhibit the creation of extension methods with the same signatures from the underlying type · scala scala3 · Discussion #17821Compiler version 3.1.1-RC1 and earlier Proposal As far as I can see, if we create an extension method with the same signature, that already exists on the underlying type, then: it's never will be u...
@NicolasRinaudo
As far as I remember, you can expect strange behaviour if you override `equals` without doing the same with `hashCode` in a consistent way.
@turb right, but that's sort of unrelated - the problem would be the same if I updated `hashCode` to be consistent with `equals`