Scala: зачем использовать неявный аргумент функции?

В вашем конкретном примере нет никакой практической пользы. На самом деле использование имплицитов для этой задачи только запутает ваш код.

В стандартном случае использовать неявные преобразования, является класс тип рисунка. Я бы сказал, что это единственный случай использования, который практически полезен. Во всех остальных случаях лучше, чтобы вещи были явными.

Вот пример класса typeclass:

// A typeclass
trait Show[a] {
  def show(a: a): String
}

// Some data type
case class Artist(name: String)

// An instance of the `Show` typeclass for that data type
implicit val artistShowInstance =
  new Show[Artist] {
    def show(a: Artist) = a.name
  }

// A function that works for any type `a`, which has an instance of a class `Show`
def showAListOfShowables[a](list: List[a])(implicit showInstance: Show[a]): String =
  list.view.map(showInstance.show).mkString(", ")

// The following code outputs `Beatles, Michael Jackson, Rolling Stones`
val list = List(Artist("Beatles"), Artist("Michael Jackson"), Artist("Rolling Stones"))
println(showAListOfShowables(list))

Этот паттерн происходит от функционального языка программирования под названием Haskell и оказался будьте более практичны, чем стандартные методы OO для написания модульного и несвязанного программного обеспечения. Главное его преимущество заключается в том, что он позволяет расширить уже существующие типы новыми функциональными возможностями, не изменяя их.

Существует множество не упомянутых деталей, таких как синтаксический сахар, def экземпляры и т. д. Это огромная тема, и, к счастью, она имеет большое освещение во всей сети. Просто погуглите для "scala Type class".

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

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

trait MyContainer[A] {
  def containedValue:A
}

Теперь, в какой-то момент, Вы найдете полезным перебрать все элементы содержащегося значения. Конечно, это имеет смысл только в том случае, если содержащееся значение является итерационным тип. Но поскольку вы хотите, чтобы ваш класс был полезен для всех типов, вы не хотите ограничивать A типом Seq, или Traversable, или чем-то подобным. В принципе, вам нужен метод, который говорит: "Я могу быть вызван только в том случае, если A имеет тип Seq." И если кто-то вызывает его, скажем, MyContainer[Int], это должно привести к ошибке компиляции.

Это возможно. Вам нужно некотороедоказательство , что A имеет тип последовательности. И вы можете сделать это с помощью Scala и implicite аргументы:

trait MyContainer[A] {
  def containedValue:A
  def aggregate[B](f:B=>B)(implicit ev:A=>Seq[B]):B =
    ev(containedValue) reduce f
}

Таким образом, если вы вызовете этот метод на MyContainer[Seq[Int]], компилятор будет искать неявный Seq[Int]=>Seq[B]. Это очень просто решить для компилятора. Потому что существует глобальная неявная функция, которая называется identity, и она всегда находится в области видимости. Его сигнатура типа выглядит примерно так: A=>A

Он просто возвращает любой аргумент, переданный ему.

Я не знаю, как называется этот паттерн. (Может ли кто-нибудь помочь?) Но я думаю, что это ловкий трюк, который очень пригодится. иногда. Вы можете увидеть хороший пример этого в библиотеке Scala, если посмотрите на сигнатуру метода Seq.sum. В случае sum используется другой неявный тип параметра; в этом случае неявный параметр являетсядоказательством того, что содержащийся тип является числовым, и поэтому сумма может быть построена из всех содержащихся значений.

Это не только использование имплицитов, и, конечно, не самое заметное, но я бы сказал, что это почетное упоминание. :- )