3

我尝试在 WriterT 上使用 flatMap 并且成功了。

所以问题可能出在我的类型上，但我找不到它有什么问题。

import cats.Monad
import cats.syntax.flatMap._

object Main extends App {
    type Optional[A] = A | Null
    
    val maybeInt1: Optional[Int] = 1
    val maybeInt2: Optional[Int] = null
    
    given Monad[Optional] with {
        def pure[A](x: A): Optional[A] = x
        def flatMap[A, B](fa: Optional[A])(f: A => Optional[B]): Optional[B] = {
            fa match {
                case null => null
                case a: A => f(a)
            }
        }
        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
            }
        }
    }

    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[Optional, Int, Int](maybeInt1, maybeInt2)) // OK: null
    println(maybeInt1.flatMap(_ => maybeInt2)) // Compilation Error
}

错误是：

值 flatMap 不是 Main.Optional[Int] 的成员。
尝试了扩展方法，但无法完全构造：
cats.syntax.flatMap.toFlatMapOps([A] =>> Any), A(given_Monad_Optional)

4

2 回答 2

7

您的定义有几个问题。

问题 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了结果，因为null在包装值内部考虑作为OptionalflatMap 期间外部缺少的分支。这是因为这种天真定义的类型违反了左恒等式

更新 关于@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 为每个 in 第一个参数返回 null，所以 pure(a).flatMap(f) == null当f(a) == 3

于 2021-04-04T07:07:55.353 回答
1

奥德斯基对主题的回应

如果将 Null 设为单独的类，或者使用 -Yexplicit-nulls 进行编译，它确实有效。

Null 的方式是底部类型。所以 Optional[C] 的每个类实例实际上都是 C。

我试图将 Optional 的定义更改为

type Optional[A] = A

然后也找不到隐式。所以这个问题看起来根本不是联合类型的问题。如果 Optional[A] 定义了一个真正的联合，它就可以工作。它看起来很像 HK 类型推断的限制，它不能推断身份。我认为这实际上是预期的。

于 2021-04-04T11:37:15.223 回答