Как прокомментировал @Michael Kohl, такое использование forall в Haskell является экзистенциальным типом и может быть точно воспроизведено в Scala с использованием конструкции forSome или подстановочного знака. Это означает, что ответ @ 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"]
@ Ответ Ким Стебель показывает канонический способ сделать это на объектно-ориентированном языке, используя подтипы. При прочих равных, это правильный путь в Скала. Я уверен, что вы это знаете, и у вас есть веские причины избегать подтипов и повторять подход, основанный на классах типов в Haskell, в Scala. Здесь идет ...
Обратите внимание, что в Haskell выше экземпляры классов типов Show для Unit, Int и Bool доступны в реализации функции 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 type не передаются из аргумента ShowBox в тело функции useShowBox и, следовательно, недоступны для использования. Если мы попытаемся это исправить, добавив дополнительный контекст, связанный с функцией useShowBox,
def useShowBox[T : Show](sb : ShowBox[T]) = sb match {
case ShowBox(t) => implicitly[Show[T]].show(t) // Now compiles ...
}
это исправляет проблему в useShowBox, но теперь мы не можем использовать его вместе с картой в нашем экзистенциально количественном списке,
scala> heteroList map useShowBox
<console>:21: error: could not find implicit value for evidence parameter
of type Show[T]
heteroList map useShowBox
^
Это потому, что когда useShowBox предоставляется в качестве аргумента функции карты, мы должны выбрать экземпляр Show на основе информации о типе, имеющейся у нас на тот момент. Ясно, что не существует только одного экземпляра Show, который будет выполнять работу для всех элементов этого списка, и поэтому его не удается скомпилировать (если бы мы определили экземпляр Show для Any, тогда это было бы, но это не то, что мы делаем после здесь ... мы хотим выбрать экземпляр класса типа на основе наиболее определенного типа каждого элемента списка).
Чтобы заставить это работать так же, как в Haskell, мы должны явно распространять экземпляры Show в теле useShowBox. Это может пойти так,
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, чтобы у нас было явное имя (showInst) для экземпляра Show для содержащегося в нем значения. Тогда в теле useShowBox мы можем явно применить его. Также обратите внимание, что сопоставление с образцом необходимо для обеспечения того, чтобы мы открывали экзистенциальный тип только один раз в теле функции.
Как и должно быть очевидно, это гораздо более вольно, чем эквивалентный Haskell, и я настоятельно рекомендую использовать решение на основе подтипов в Scala, если только у вас нет веских причин поступать иначе.
Редактировать
Как отмечено в комментариях, определение ShowBox в Scala выше имеет видимый параметр типа, которого нет в оригинале Haskell. Я думаю, что на самом деле весьма поучительно посмотреть, как мы можем исправить это, используя абстрактные типы.
Сначала мы заменим параметр типа на абстрактный член типа и заменим параметры конструктора на абстрактные значения,
trait ShowBox {
type T
val t : T
val showInst : Show[T]
}
Теперь нам нужно добавить метод фабрики, который в противном случае классы case предоставили бы нам бесплатно,
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 и подстановочных знаков именно так вы и представляли экзистенциальные типы.)
Теперь у нас есть экзистенциал точно в том же месте, что и в оригинальном Хаскеле. Я думаю, что это настолько близко к верному исполнению, как вы можете получить в Scala.