В Скале

Question

В Скале

Как показано ниже, в Haskell можно хранить в списке значения разнородных типов с определенными границами контекста на них:

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

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

Как я могу добиться того же в Scala, желательно без подтипов?

50

scala haskell forall

Источник

user192247 27 авг '11 в 09:31

5 ответов

Решение

ShowBox Пример, который вы привели, включает экзистенциальный тип. Я переименовываю ShowBox конструктор данных для SB чтобы отличить его от типа:

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

Мы говорим s является "экзистенциальным", но forall вот универсальный квантификатор, который относится к SB конструктор данных. Если мы спросим о типе SB конструктор с явным forall включается, это становится намного понятнее:

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

Это ShowBox на самом деле состоит из трех вещей:

Тип s
Значение типа s
Экземпляр Show s,

Потому что тип s становится частью построенного ShowBoxЭто экзистенциально количественно. Если бы Haskell поддерживал синтаксис для экзистенциального количественного определения, мы могли бы написать ShowBox как псевдоним типа:

type ShowBox = exists s. Show s => s

Scala поддерживает этот вид экзистенциальной количественной оценки, и ответ Майлза дает подробности, используя черту, которая состоит именно из этих трех вещей выше. Но так как это вопрос о "forall in Scala", давайте сделаем это точно так же, как это делает Haskell.

Конструкторы данных в Scala не могут быть явно определены количественно с помощью forall. Тем не менее, каждый метод в модуле может быть. Таким образом, вы можете эффективно использовать полиморфизм конструктора типов в качестве универсального количественного определения. Пример:

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

Тип Scala Forall[F], учитывая некоторые F, тогда эквивалентно типу Haskell forall a. F a,

Мы можем использовать эту технику, чтобы добавить ограничения к аргументу типа.

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

Значение типа F 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 Метод является универсально количественным конструктором данных. Вы можете видеть, что он принимает тип S, экземпляр Show[S]и значение типа Sтак же, как версия на Haskell.

Вот пример использования:

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

Более прямым кодированием в Scala может быть использование класса case:

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)

В этом случае List[ShowBox] в основном эквивалентно List[String], но вы можете использовать эту технику с чертами, отличными от Show чтобы получить что-то более интересное.

Это все с помощью Show класс от Скалаз.

25

Источник

user3434 27 авг '11 в 19:36

Я не думаю, что перевод 1-к-1 из 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)

5

Источник

user46450 27 авг '11 в 10:36

(Изменить: добавление методов, чтобы показать, чтобы ответить на комментарий.)

Я думаю, что вы можете получить то же самое, используя неявные методы с границами контекста:

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

3

Источник

user220447 27 авг '11 в 09:44

Почему бы и нет:

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 может перевести "монстров типа Хаскелла" в очень простой.

0

Источник

user905593 28 авг '11 в 13:48

Другие вопросы по тегам scala haskell forall

user146737 27 авг '11 в 12:08 2011-08-27 12:08 · Accepted Answer · 2011-08-27 12:08

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

Тем не менее, в оригинале Haskell чего-то не хватает, так как экземпляры его типа ShowBox также захватывают соответствующие экземпляры класса Show таким образом, который делает их доступными для использования в элементах списка, даже когда точный базовый тип был количественно определен количественно., Ваш комментарий к ответу @ paradigmatic предполагает, что вы хотите написать что-то эквивалентное следующему Хаскеллу:

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