scala - Scala 中的 forall

Question

如下所示，在 Haskell 中，可以将具有特定上下文边界的异构类型的值存储在列表中:

data ShowBox = forall s. Show s => ShowBox s

heteroList :: [ShowBox]
heteroList = [ShowBox (), ShowBox 5, ShowBox True]

我怎样才能在 Scala 中实现相同的目标，最好不要子类型化？

Answer 1

正如@Michael Kohl 评论的那样，在 Haskell 中使用 forall 是一种存在类型，可以使用 forSome 构造或通配符在 Scala 中完全复制。这意味着@paradigmatic 的答案在很大程度上是正确的。

尽管如此，相对于 Haskell 的原始版本还是有一些缺失，即 ShowBox 类型的实例也以某种方式捕获了相应的 Show 类型类实例，这使得它们可用于列表元素，即使确切的基础类型已经存在量化了.您对@paradigmatic 的回答的评论表明您希望能够编写与以下 Haskell 等效的内容，

data ShowBox = forall s. Show s => ShowBox s

heteroList :: [ShowBox]
heteroList = [ShowBox (), ShowBox 5, ShowBox True]

useShowBox :: ShowBox -> String
useShowBox (ShowBox s) = show s

-- Then in ghci ...

*Main> map useShowBox heteroList
["()","5","True"]

@Kim Stebel 的回答显示了通过利用子类型在面向对象的语言中执行此操作的规范方法。在其他条件相同的情况下，这是使用 Scala 的正确方法。我相信您知道这一点，并且有充分的理由希望避免子类型化并在 Scala 中复制 Haskell 的基于类型类的方法。开始 ...

请注意，在上面的 Haskell 中，Unit、Int 和 Bool 的 Show 类型类实例在 useShowBox 函数的实现中可用。如果我们尝试将其直接翻译成 Scala，我们会得到类似的结果，

trait Show[T] { def show(t : T) : String }

// Show instance for Unit
implicit object ShowUnit extends Show[Unit] {
  def show(u : Unit) : String = u.toString
}

// Show instance for Int
implicit object ShowInt extends Show[Int] {
  def show(i : Int) : String = i.toString
}

// Show instance for Boolean
implicit object ShowBoolean extends Show[Boolean] {
  def show(b : Boolean) : String = b.toString
}

case class ShowBox[T: Show](t:T)

def useShowBox[T](sb : ShowBox[T]) = sb match {
  case ShowBox(t) => implicitly[Show[T]].show(t)
  // error here      ^^^^^^^^^^^^^^^^^^^
} 

val heteroList: List[ShowBox[_]] = List(ShowBox(()), ShowBox(5), ShowBox(true))

heteroList map useShowBox

这在 useShowBox 中编译失败，如下所示，

<console>:14: error: could not find implicit value for parameter e: Show[T]
         case ShowBox(t) => implicitly[Show[T]].show(t)
                                      ^

这里的问题是，与 Haskell 的情况不同，Show 类型类实例不会从 ShowBox 参数传播到 useShowBox 函数的主体，因此无法使用。如果我们尝试通过在 useShowBox 函数上添加额外的上下文绑定(bind)来解决这个问题，

def useShowBox[T : Show](sb : ShowBox[T]) = sb match {
  case ShowBox(t) => implicitly[Show[T]].show(t) // Now compiles ...
} 

这解决了 useShowBox 中的问题，但现在我们不能将它与存在量化列表上的 map 结合使用，

scala> heteroList map useShowBox
<console>:21: error: could not find implicit value for evidence parameter
                     of type Show[T]
              heteroList map useShowBox
                             ^

这是因为当 useShowBox 作为参数提供给 map 函数时，我们必须根据我们当时拥有的类型信息选择 Show 实例。显然，不仅有一个 Show 实例可以为这个列表的所有元素完成这项工作，因此编译失败(如果我们为 Any 定义了一个 Show 实例，那么就会有，但这不是我们想要的在这里之后……我们想根据每个列表元素的最具体的类型来选择一个类型类实例)。

为了让它像在 Haskell 中一样工作，我们必须在 useShowBox 的主体内显式地传播 Show 实例。可能是这样的，

case class ShowBox[T](t:T)(implicit val showInst : Show[T])

val heteroList: List[ShowBox[_]] = List(ShowBox(()), ShowBox(5), ShowBox(true))

def useShowBox(sb : ShowBox[_]) = sb match {
  case sb@ShowBox(t) => sb.showInst.show(t)
}

然后在 REPL 中，

scala> heteroList map useShowBox
res7: List[String] = List((), 5, true)

请注意，我们已经对 ShowBox 上的上下文绑定(bind)进行了脱糖，以便我们为包含的值的 Show 实例提供一个显式名称 (showInst)。然后在 useShowBox 的主体中我们可以明确地应用它。还要注意，模式匹配对于确保我们只在函数体中打开一次存在类型是必不可少的。

很明显，这比等效的 Haskell 更加冗长，我强烈建议在 Scala 中使用基于子类型的解决方案，除非您有非常好的理由不这样做。

编辑

正如评论中所指出的，上面 ShowBox 的 Scala 定义有一个可见的类型参数，它在 Haskell 原始版本中不存在。我认为看看我们如何使用抽象类型来纠正这个问题实际上很有启发性。

首先我们用抽象类型成员替换类型参数，用抽象值替换构造函数参数，

trait ShowBox {
  type T
  val t : T
  val showInst : Show[T]
}

我们现在需要添加工厂方法，否则案例类将免费提供给我们，

object ShowBox {
  def apply[T0 : Show](t0 : T0) = new ShowBox {
    type T = T0
    val t = t0
    val showInst = implicitly[Show[T]]
  } 
}

我们现在可以在之前使用 ShowBox[_] 的任何地方使用普通 ShowBox ......抽象类型成员现在为我们扮演存在量词的角色，

val heteroList: List[ShowBox] = List(ShowBox(()), ShowBox(5), ShowBox(true))

def useShowBox(sb : ShowBox) = {
  import sb._
  showInst.show(t)
}

heteroList map useShowBox

(值得注意的是，在 Scala 中引入显式 forSome 和通配符之前，这正是表示存在类型的方式。)

我们现在在与原始 Haskell 中完全相同的位置拥有存在。我认为这是您在 Scala 中所能获得的最接近忠实的演绎。