不能使用flatMap作为自写monad实例的扩展方法

你的定义有几个问题。

问题 1. 您使用的是非参数类型的非不透明类型别名

ietype Optional[A] = A | Null是一个会尽快展开的类型表达式。当您使用它作为结果类型时，您实际得到的是

val maybeInt1: Int | Null = 1
val maybeInt2: Int | Null = null


所以当编译器有类似的东西时

implicit def toFlatMapOps[F[_], A](fa: F[A])(implicit F: Monad[F]): MonadOps[F, A]


从scala 2库或scala 3中的等效扩展导入，最后来到maybeOption.flatMap，

然后尝试应用以前的扩展方法，

它无法对表达式进行类型检查

toFlatMapOps(maybeInt1).flatMap(_ => maybeInt2)

所以现在你有Int | Null一个参数，因为Optional已经扩展并且需要计算相应的F[_]and A，它有很多解决方案，例如

1. F[X] = Int | X , A = Null


2. F[X] = X | Null, A = Int


3. F[X] = A | Null, A = Nothing


4. F[X] = [X] =>> X, A = Int | Null

所以scala 自然不会尝试猜测。

尽管 scala 3 编译器可以在这里使用诸如隐式上下文值等附加信息，但这里匹配Monad的最高优先级的隐式值是

given Monad[Optional]


现在可以尝试应用 toFlatMapOps[F = Maybe](maybeInt1 : Int | Null) 然后F[X] = X | Null你需要计算A知道它F[A] = Null | A也有许多合理的解决方案

1. A = Int


2. A = Int | Null

因此，即使 Scala 不会在第一步失败，它也会卡在这里

解决方案 1. 使用不透明类型别名

添加scalacOptions += "-Yexplicit-nulls"到您的 sbt 配置并尝试此代码

import cats.Monad
import cats.syntax.flatMap.given
object Optional:
opaque type Optional[+A] >: A | Null = A | Null
extension [A] (oa: Optional[A]) def value : A | Null = oa
given Monad[Optional] with
def pure[A](x: A): Optional[A] = x
def flatMap[A, B](fa: A | Null)(f: A => B | Null) =
if fa == null then null else f(fa)
def tailRecM[A, B](a: A)(f: A => Optional[Either[A, B]]): Optional[B] =
f(a) match
case null => null
case Left(a1) => tailRecM(a1)(f)
case Right(b) => b
type Optional[+A] = Optional.Optional[A]
@main def run =
val maybeInt1: Optional[Int] = 1
val maybeInt2: Optional[Int] = null
def f[F[_]: Monad, A, B](a: F[A], b: F[B]) = a.flatMap(_ => b) println(Monad[Optional].flatMap(maybeInt1)(_ => maybeInt2)) //OK: null
println(f(maybeInt1, maybeInt2)) // OK: null
println(maybeInt1.flatMap(_ => maybeInt2)) // Compilation Error


问题 2. 这种类型不是 monad

即使在这个固定版本中，Optional[A]基本的一元法则也失败了考虑这个代码

def orElse[F[_], A](fa: F[Optional[A]])(default: => F[A])(using F: Monad[F]): F[A] =
fa.map(_.value).flatMap(fb => if fb == null then default else F.pure(fb : A))
def filterOne(x: Int): Optional[Int] = if x == 1 then null else x - 1
println(orElse(maybeInt1.map(filterOne))(3))


第一种方法尝试使用给定的计算一元值解决缺失值，第二种方法只是过滤掉那些。那么，当这样的评估时，我们期望看到什么？

orElse(maybeInt1.map(filterOne))(3)


我们可能取非空，然后用1缺失的地方替换，然后立即使用提供的修复它3。所以我希望看到3但实际上，我们获得null了结果，因为在 flatMap 期间null将包装值视为外部的缺失分支Optional。这是因为这种天真的定义类型违反了左恒等律

更新

关于@n-pronouns-m 的评论

这个定义如何违反左身份法。左身份指出

pure(a).flatMap(f) == f(a)
for all types A, B, and values a: A, f: A => Optional[B]


所以让我们取 A = Optional[Int], B = Int, A = null, f(a) = if a == null then 3 else 2

pure(a) 仍然为 null，flatMap 为第一个参数中的每个参数返回 null，所以

pure(a).flatMap(f) == null虽然f(a) == 3