So I want to make sure that the extractor in the case match will give an alias to it the correct generic type, if possible.
trait MyT[A]
case class MyC[A](t: MyT[A])
def foo: MyC[_]
def go[A](t: MyT[A]): Option[MyC[A]] = foo match {
case m@MyC(`t`) => Some(m.copy(t = t))
case _ => None
}
This works but I would prefer to not do the m.copy(t = t). Basically m@ will bind to MyC[Any], but I want it to bind to MyC[A]. Is this possible, maybe with a custom unapply?
You could try to explicitly ascribe the type parameter A to the pattern matched MyC, and eliminate the warnings by @unchecked:
trait MyT[A]
case class MyC[A](t: MyT[A])
def foo: MyC[_] = ???
def go[A](t: MyT[A]): Option[MyC[A]] = foo match {
case m: MyC[A @unchecked] if (m.t == t) => Some(m)
case _ => None
}
@unchecked hurts me.
m against a MyC(`t`) without complaining? Or that the compiler allows invocations of == on values which aren't even necessary of same type?== it uses .equals no? I'm not sure what you mean with the first one about m vs MyC(`t`)== uses equals. I just don't see any great difference between the above @unchecked and something like def foobar[A](a: A, b: AnyRef): Option[A] = { if (a == b) Some(a) else None }. When using ==, it doesn't even require an @unchecked annotation for essentially same kind of "unsafe"-ish comparison.a == b you can conclude that b is of type A in the then-branch of the if. Likewise, if m.t == t, you can derive that m.t must be of type MyT[A], therefore m must be of type MyC[A]. The compiler doesn't see that, because it doesn't infer anything useful from the fact that m.t == t. This is not flow-sensitive typing, unfortunately...
m.copy(t = t)will just callMyC(t), so you could write that instead and don't needmhere (which may not apply to your real code, of course). Of course, reusingmwould be better, but this seems to be a strict improvement oncopyto me.MyC, I would need to change the case match as well as the result, whereas copy means I only need to change the case match.A, though.