48

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

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

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

如何在 Scala 中实现相同的目标，最好不使用子类型？

4

5 回答 5

62

正如@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 函数上添加额外的上下文来解决这个问题，

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

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

编辑

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

首先我们将类型参数替换为抽象类型成员，并将构造函数参数替换为抽象 val，

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 中引入 explict forSome 和通配符之前，这正是您表示存在类型的方式。）

我们现在在与原始 Haskell 完全相同的地方拥有存在主义。我认为这是您在 Scala 中可以得到的最接近忠实的演绎。

于 2011-08-27T12:08:54.863 回答
24

您给出的ShowBox示例涉及存在类型。我正在重命名ShowBox数据构造函数以SB将其与类型区分开来：

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

我们说s是“存在的”，但这里是一个与数据构造函数forall有关的通用量词。如果我们在显式打开SB的情况下询问SB构造函数的类型，这将变得更加清晰：forall

SB :: forall s. Show s => s -> ShowBox

也就是说，aShowBox实际上是由三件事构成的：

  1. 一种s
  2. 类型的值s
  3. 的一个实例Show s。

因为类型s成为构造的一部分ShowBox，所以它是存在量化的。如果 Haskell 支持存在量化的语法，我们可以写成ShowBox类型别名：

type ShowBox = exists s. Show s => s

Scala 确实支持这种存在量化，而 Miles 的回答使用由上述三件事组成的特征给出了详细信息。但由于这是一个关于“forall in Scala”的问题，让我们像 Haskell 一样做。

Scala 中的数据构造函数不能用 forall 显式量化。但是，模块上的每个方法都可以。因此，您可以有效地使用类型构造函数多态性作为通用量化。例子：

trait Forall[F[_]] {
  def apply[A]: F[A]
}

Forall[F]给定一些Scala 类型F就等同于 Haskell 类型forall a. F a。

我们可以使用这种技术向类型参数添加约束。

trait SuchThat[F[_], G[_]] {
  def apply[A:G]: F[A]
}

typeF SuchThat G的值类似于 Haskell 类型的值forall a. G a => F a。的实例G[A]如果存在，则由 Scala 隐式查找。

现在，我们可以使用它来编码您的ShowBox...

import scalaz._; import Scalaz._ // to get the Show typeclass and instances

type ShowUnbox[A] = ({type f[S] = S => A})#f SuchThat Show

sealed trait ShowBox {
  def apply[B](f: ShowUnbox[B]): B  
}

object ShowBox {
  def apply[S: Show](s: => S): ShowBox = new ShowBox {
    def apply[B](f: ShowUnbox[B]) = f[S].apply(s)
  }
  def unapply(b: ShowBox): Option[String] =
    b(new ShowUnbox[Option[String]] {
      def apply[S:Show] = s => some(s.shows)
  })
}

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

该ShowBox.apply方法是通用量化的数据构造函数。您可以看到它需要一个 type S、一个 的实例Show[S]和一个 type 的值S，就像 Haskell 版本一样。

这是一个示例用法：

scala> heteroList map { case ShowBox(x) => x }
res6: List[String] = List((), 5, true)

Scala 中更直接的编码可能是使用案例类：

sealed trait ShowBox
case class SB[S:Show](s: S) extends ShowBox {
  override def toString = Show[S].shows(s)
}

然后：

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

在这种情况下， aList[ShowBox]基本上等同于 a List[String]，但是您可以将此技术与特征一起使用，而不是Show获得更有趣的东西。

这都是使用ScalazShow的类型类。

于 2011-08-27T19:36:26.827 回答
5

我认为从 Haskell 到 Scala 的一对一翻译在这里是不可能的。但是你为什么不想使用子类型呢？如果您要使用的类型（例如 Int）缺少 show 方法，您仍然可以通过隐式转换添加它。

scala> trait Showable { def show:String }
defined trait Showable

scala> implicit def showableInt(i:Int) = new Showable{ def show = i.toString }
showableInt: (i: Int)java.lang.Object with Showable

scala> val l:List[Showable] = 1::Nil
l: List[Showable] = List($anon$1@179c0a7)

scala> l.map(_.show)
res0: List[String] = List(1)
于 2011-08-27T10:36:14.030 回答
3

（编辑：添加方法来显示，回答评论。）

我认为您可以使用具有上下文边界的隐式方法获得相同的结果：

trait Show[T] {
  def apply(t:T): String
}
implicit object ShowInt extends Show[Int] {
  def apply(t:Int) = "Int("+t+")"
}
implicit object ShowBoolean extends Show[Boolean] {
  def apply(t:Boolean) = "Boolean("+t+")"
}

case class ShowBox[T: Show](t:T) {
  def show = implicitly[Show[T]].apply(t)
}

implicit def box[T: Show]( t: T ) =
  new ShowBox(t)

val lst: List[ShowBox[_]] = List( 2, true )

println( lst ) // => List(ShowBox(2), ShowBox(true))

val lst2 = lst.map( _.show )

println( lst2 ) // => List(Int(2), Boolean(true))
于 2011-08-27T09:44:31.170 回答
0

为什么不：

trait ShowBox {
    def show: String
}

object ShowBox {
    def apply[s](x: s)(implicit i: Show[s]): ShowBox = new ShowBox {
        override def show: String = i.show(x)
    }
}

正如当局的回答所暗示的那样，我经常对 Scala 可以将“Haskell 类型的怪物”翻译成非常简单的怪物感到惊讶。

于 2011-08-28T13:48:06.397 回答