конечно. У акки есть отличный пример этого по отношению к своим актерам. Когда вы находитесь внутри актера receive метод, вы можете отправить сообщение другому актеру. Когда вы это сделаете, Akka будет связывать (по умолчанию) текущего актера как sender из сообщения, например:

trait ScalaActorRef { this: ActorRef =>
  ...

  def !(message: Any)(implicit sender: ActorRef = null): Unit

  ...
}

The sender подразумевается. В актере есть определение, которое выглядит так:

trait Actor {
  ...

  implicit val self = context.self

  ...
}

это создает неявное значение в рамках вашего собственного кода, и это позволяет делать простые вещи, как это:

someOtherActor ! SomeMessage

теперь вы можете сделать это, если хотите:

someOtherActor.!(SomeMessage)(self)

или

someOtherActor.!(SomeMessage)(null)

или

someOtherActor.!(SomeMessage)(anotherActorAltogether)

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

одним из примеров могут быть операции сравнения на Traversable[A]. Е. Г. max или sort:

def max[B >: A](implicit cmp: Ordering[B]) : A

они могут быть разумно определены только тогда, когда есть операция < on A. Так, без неявные преобразования, мы должны поставить контекст Ordering[B] каждый раз, когда мы хотели бы использовать эту функцию. (Или отказаться от типа статической проверки внутри max и риск ошибки во время выполнения броска.)

Если, однако, неявное сравнение класс в области видимости, например некоторые Ordering[Int], мы можем просто использовать его сразу или просто изменить метод сравнения, предоставляя какое-либо другое значение для неявного параметра.

конечно, имплициты могут быть затенены и, таким образом, могут быть ситуации, в которых фактический имплицит, который находится в области действия, недостаточно ясен. Для простого использования max или sort это действительно может быть достаточно, чтобы иметь фиксированный порядок trait on Int и использовать некоторый синтаксис, чтобы проверить, доступна ли эта черта. Но это будет означать что не может быть никаких дополнительных черт, и каждый фрагмент кода должен будет использовать черты, которые были первоначально определены.

дополнение:
ответ глобальная переменная сравнение.

я думаю, вы правы, что в коде обрезается как

implicit val num = 2
implicit val item = "Orange"
def shopping(implicit num: Int, item: String) = {
  "I’m buying "+num+" "+item+(if(num==1) "." else "s.")
}

scala> shopping
res: java.lang.String = I’m buying 2 Oranges.

он может пахнуть гнилыми и злыми глобальными переменными. Решающим моментом, однако, является то, что может быть только одна неявная переменная per типа в область. Ваш пример с двумя Ints не будет работать.

кроме того, это означает, что практически, неявные переменные используются только тогда, когда есть не обязательно уникальный, но внятный экземпляра типа. Элемент self ссылка актера является хорошим примером для такой вещи. Пример класса type-это еще один пример. Там могут быть десятки алгебраических сравнений для любого типа, но есть один, который является особенным. (На другом уровне, фактическое номер строки в самом коде также может быть хорошая неявная переменная, если она использует очень отличительный тип.)

вы обычно не используете implicits для повседневных типов. И со специализированными типами (например Ordering[Int]) существует не слишком большой риск в затенении их.

еще одним хорошим общим использованием неявных параметров является то, чтобы тип возвращаемого метода зависел от типа некоторых передаваемых ему параметров. Хорошим примером, упомянутым Йенсом, является структура коллекций и методы, такие как map, чья подпись, как правило, является:

def map[B, That](f: (A) ⇒ B)(implicit bf: CanBuildFrom[GenSeq[A], B, That]): That

обратите внимание, что возвращаемый тип That определяется по лучшей подгонке CanBuildFrom что компилятор может найти.

другой пример этого см. что ответ. Там, возвращаемый тип метода Arithmetic.apply определяется в соответствии с определенным неявным типом параметра (BiConverter).

это просто, Просто помните:

• чтобы объявить переменную, которая должна быть передана как неявная тоже
• объявить все неявные параметры после неявных параметров в отдельном ()

например

def myFunction(): Int = {
  implicit val y: Int = 33
  implicit val z: Double = 3.3

  functionWithImplicit("foo") // calls functionWithImplicit("foo")(y, z)
}

def functionWithImplicit(foo: String)(implicit x: Int, d: Double) = // blar blar

основываясь на моем опыте, нет реального хорошего примера для использования параметров implicits или преобразования implicits.

небольшое преимущество использования implicits (не нужно явно писать параметр или тип) является избыточным по сравнению с проблемами, которые они создают.

Я являюсь разработчиком в течение 15 лет и работаю с scala в течение последних 1,5 лет.

Я много раз видел ошибки, которые были вызваны разработчиком, не знающим о том, что использовать неявные преобразования, и что конкретная функция на самом деле возвращает другой тип, тот, что указан. Из-за неявного преобразования.

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

import org.some.common.library.{TypeA, TypeB}

или:

import org.some.common.library._

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

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

после того, как вы столкнулись с ошибкой, его не так просто задача найти причину. Вы должны провести какое-то глубокое расследование.

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

дополнительные причины того, почему я вообще против неявные преобразования являются:

• они делают код трудно понять (меньше кода, но вы не знаете, что он делает)
• время компиляции. код scala компилирует гораздо медленнее при использовании неявные преобразования несколько.
• на практике он меняет язык со статически типизированного на динамически типизированный. Это правда, что, следуя очень строгим рекомендациям по кодированию, вы можете избежать таких ситуаций, но в реальном мире это не всегда так. Даже использование IDE "удалить неиспользуемый импорт" может привести к тому, что ваш код все еще будет компилироваться и выполняться, но не так, как до удаления "неиспользуемого" импорта.

нет возможности компилировать scala без implicits (если есть, пожалуйста, поправьте меня), и если бы был вариант, ни одна из общих библиотек Scala сообщества не компилировалась бы.

по всем вышеперечисленным причинам, я думаю, что имплициты являются одной из худших практик, которые использует язык scala.

Scala имеет много отличных функций, и многие не так велики.

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

неявные параметры активно используются в API коллекции. Многие функции получают неявный CanBuildFrom, который гарантирует, что вы получите "лучшую" реализацию коллекции результатов.

без неявные преобразования, вы бы либо передать такую вещь все время, что бы сделать нормального использования громоздкой. Или используйте менее специализированные коллекции, которые будут раздражать, потому что это будет означать, что вы потеряете производительность/мощность.

я комментирую этот пост немного поздно, но я начал изучать scala в последнее время. Даниэль и другие дали хороший фон о неявном ключевом слове. Я бы дал мне два цента на неявную переменную с точки зрения практического использования.

Scala лучше всего подходит для написания кодов Apache Spark. В Spark у нас есть контекст spark и, скорее всего, класс конфигурации, который может извлекать конфигурационные ключи/значения из файла конфигурации.

Теперь, Если Я есть абстрактный класс и если я объявляю объект конфигурации и искры контекста следующим образом: -

abstract class myImplicitClass {

implicit val config = new myConfigClass()

val conf = new SparkConf().setMaster().setAppName()
implicit val sc = new SparkContext(conf)

def overrideThisMethod(implicit sc: SparkContext, config: Config) : Unit
}

class MyClass extends myImplicitClass {

override def overrideThisMethod(implicit sc: SparkContext, config: Config){

/*I can provide here n number of methods where I can pass the sc and config 
objects, what are implicit*/
def firstFn(firstParam: Int) (implicit sc: SparkContext, config: Config){ 
    /*I can use "sc" and "config" as I wish: making rdd or getting data from cassandra, for e.g.*/
    val myRdd = sc.parallelize(List("abc","123"))
}
def secondFn(firstParam: Int) (implicit sc: SparkContext, config: Config){
 /*following are the ways we can use "sc" and "config" */

        val keyspace = config.getString("keyspace")
        val tableName = config.getString("table")
        val hostName = config.getString("host")
        val userName = config.getString("username")
        val pswd = config.getString("password")

    implicit val cassandraConnectorObj = CassandraConnector(....)
    val cassandraRdd = sc.cassandraTable(keyspace, tableName)
}

}
}