форалл в Scala

как прокомментировал @Michael Kohl, это использование forall в Haskell является экзистенциальным типом и может быть точно реплицировано в Scala с помощью конструкции forSome или подстановочного знака. Это означает, что ответ @paradigmatic в значительной степени правильный.

тем не менее, там что-то отсутствует относительно оригинала Haskell, который заключается в том, что экземпляры его типа ShowBox также захватывают соответствующие экземпляры класса Show type таким образом, что делает их доступными для использования в списке элементы, даже если точный базовый тип был экзистенциально количественно определен. Ваш комментарий к ответу @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"]

@Ким стебель показывает канонический способ сделать это в объектно-ориентированном языке по эксплуатации субтипы. При прочих равных условиях это правильный путь в Scala. Я уверен, что вы это знаете, и у вас есть веские причины избегать подтипов и реплицируйте подход на основе класса типа Haskell в Scala. Здесь идет ...

обратите внимание, что в Haskell выше экземпляров класса Show type для 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, тип шоу экземпляры класса не распространяются из аргумента 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 поставляется в качестве аргумента функции карты, у нас есть чтобы выбрать экземпляр Show на основе информации о типе, которую мы имеем на данный момент. Очевидно, что существует не только один экземпляр Show, который будет выполнять работу для всех элементов этого списка, и поэтому это не удается скомпилировать (если бы мы определили экземпляр Show для любого, тогда было бы, но это не то, что мы здесь ищем ... мы хотим выбрать экземпляр класса типа на основе наиболее конкретного типа каждого элемента списка).

чтобы заставить это работать так же, как в 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 мы можем явно применить его. Также обратите внимание, что соответствие шаблону необходимо для обеспечения того, чтобы мы открывали экзистенциальный тип только один раз в теле функция.

как должно быть очевидно, это намного больше vebose, чем эквивалентный Haskell, и я настоятельно рекомендую использовать решение на основе подтипа в Scala, если у вас нет очень веских причин делать иначе.

редактировать

как указано в комментариях, определение Scala ShowBox выше имеет видимый параметр типа, который отсутствует в оригинале Haskell. Я думаю, это довольно поучительно, чтобы увидеть, как мы можно исправить это, используя абстрактные типы.

Сначала мы заменим параметр типа абстрактным членом типа и заменим параметры конструктора абстрактными vals,

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

(стоит отметить, что до введения explict forSome и подстановочных знаков в Scala именно так вы представляли бы экзистенциальные типы.)

теперь мы имеем экзистенциальное в том же самом месте, что и в оригинальном Хаскелле. Я думаю, что это так близко к верному исполнению, как вы можете получить в Scala.