forall w Scali

Jak skomentował @ Michael Kohl, użycie forall w Haskell jest typem egzystencjalnym i może być dokładnie powtórzone w Scali za pomocą konstrukcji forSome lub symbolu wieloznacznego. Oznacza to, że odpowiedź @paradigmatic jest w dużej mierze poprawna.

Niemniej jednak czegoś tam brakuje w stosunku do oryginału Haskell, który polega na tym, że instancje jego typu ShowBox przechwytywają również odpowiednie instancje klasy Show type w sposób, który sprawia, że są one dostępne do użycia na elementach listy nawet gdy dokładny typ bazowy został określony egzystencjalnie. Twój komentarz do odpowiedzi @ paradigmatic sugeruje, że chcesz być w stanie napisać coś równoważnego do następującego 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"]

Odpowiedź Kima Stebela pokazuje kanoniczny sposób robienia tego w języku zorientowanym obiektowo, wykorzystując podtypy. Inne rzeczy są równe, to jest właściwy sposób, aby przejść w Scali. Jestem pewien, że wiesz o tym i masz dobre powody, aby unikać podtypowania i powielania Haskella podejście oparte na klasach typu w Scali. Zaczyna się ...

Zauważ, że w Haskell powyżej wystąpienia klasy Show type dla Unit, Int i Bool są dostępne w implementacji funkcji useShowBox. Jeśli spróbujemy bezpośrednio przetłumaczyć to na Scalę, otrzymamy coś w stylu,

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

I to nie kompiluje się w useShowBox w następujący sposób,

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

Problem polega na tym, że w przeciwieństwie do przypadku Haskella, instancje Show type nie są propagowane z Argument ShowBox do ciała funkcji useShowBox, a więc nie są dostępne do użycia. Jeśli spróbujemy to naprawić, dodając dodatkowy kontekst związany z funkcją useShowBox,

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

To rozwiązuje problem w useShowBox, ale teraz nie możemy go używać w połączeniu z mapą na naszej egzystencjalnie ilościowej liście,

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

Dzieje się tak, ponieważ gdy useShowBox jest dostarczany jako argument do funkcji map, musimy wybrać instancję Show na podstawie informacji o typie w tym momencie. Oczywiście nie istnieje tylko jedna instancja Show, która wykona zadanie dla wszystkich elementów tej listy, a więc ta nie zostanie skompilowana (gdybyśmy zdefiniowali instancję Show dla dowolnej, to byłaby, ale nie o to tu chodzi ... chcemy wybrać instancję klasy type na podstawie najbardziej określonego typu każdego elementu listy).

Aby to działało w taki sam sposób jak w Haskell, musimy wyraźnie propagować instancje Show w ciele useShowBox. To może wyglądać tak:

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)
}

Następnie w REPL,

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

Zauważ, że usunęliśmy przypisany kontekst w ShowBox tak, że mamy jawną nazwę (showInst) dla wystąpienia Show dla zawartej wartości. Następnie w ciele useShowBox możemy go jawnie zastosować. Zauważ również, że dopasowanie wzorca jest niezbędne, aby upewnić się, że typ egzystencjalny otworzymy tylko raz w ciele funkcji.

Jak powinno być oczywiste, jest to o wiele bardziej vebose niż równoważny Haskell i zdecydowanie polecam użycie rozwiązania opartego na podtypie w Scali, chyba że masz bardzo dobre powody, aby zrobić inaczej.

Edit

Jak wspomniano w komentarzach, definicja Scala ShowBox powyżej ma widoczny parametr typu, który nie jest obecny w oryginale Haskell. Myślę, że to całkiem pouczające zobaczyć, jak możemy to naprawić używając abstrakcyjnych typów.

Najpierw zamieniamy parametr type na abstrakcyjny Typ member i zastąp parametry konstruktora abstrakcyjnymi vals,

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

Teraz musimy dodać metodę fabryczną, którą klasy case dałyby nam za Darmo,

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

Możemy teraz używać zwykłego Showboxa tam, gdzie wcześniej używaliśmy Showboxa [_]... element typu abstrakcyjnego odgrywa dla nas rolę kwantyfikatora egzystencjalnego,

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

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

heteroList map useShowBox

(Warto zauważyć, że przed wprowadzeniem explict forSome i wildcards w Scali było to dokładnie tak, jak reprezentowałby typy egzystencjalne.)

Mamy teraz egzystencjalne dokładnie w tym samym miejscu, co jest w oryginalnym Haskell. Myślę, że to jest tak blisko wiernego wykonania, jak można dostać w Scali.