Implizites in Scala verstehen

Question

Ich war meinen Weg durch die Scala playframework Tutorial und ich stieß auf diesen Codeschnipsel, die mich verwirrt hatte:

def newTask = Action { implicit request =>
taskForm.bindFromRequest.fold(
        errors => BadRequest(views.html.index(Task.all(), errors)),
        label => {
          Task.create(label)
          Redirect(routes.Application.tasks())
        } 
  )
}

Also beschloss ich, nachzuforschen, und stieß auf diese Stelle .

Ich verstehe es immer noch nicht.

Was ist der Unterschied zwischen:

implicit def double2Int(d : Double) : Int = d.toInt

et

def double2IntNonImplicit(d : Double) : Int = d.toInt

abgesehen von der offensichtlichen Tatsache, dass sie unterschiedliche Methodennamen haben.

Wann sollte ich die implicit und warum?

Answer 1

Ein sehr einfaches Beispiel für Implicits in Scala.

Implizite Parameter :

val value = 10
implicit val multiplier = 3
def multiply(implicit by: Int) = value * by
val result = multiply // implicit parameter wiil be passed here
println(result) // It will print 30 as a result

Anmerkung: Hier multiplier wird implizit an die Funktion multiply . Fehlende Parameter für den Funktionsaufruf werden nach Typ im aktuellen Bereich gesucht, was bedeutet, dass der Code nicht kompiliert wird, wenn es keine implizite Variable vom Typ Int im Bereich gibt.

Implizite Konvertierungen :

implicit def convert(a: Double): Int = a.toInt
val res = multiply(2.0) // Type conversions with implicit functions
println(res)  // It will print 20 as a result

Anmerkung: Wenn wir anrufen multiply Funktion, die einen Double-Wert übergibt, wird der Compiler versuchen, die implizite Konvertierungsfunktion im aktuellen Bereich zu finden, die Folgendes konvertiert Int à Double (Als Funktion multiply akzeptieren Int Parameter). Wenn es keinen impliziten convert Funktion, wird der Compiler den Code nicht kompilieren.

Answer 2

Ich hatte genau dieselbe Frage wie Sie, und ich denke, ich sollte mit Ihnen teilen, wie ich angefangen habe, es anhand einiger wirklich einfacher Beispiele zu verstehen (beachten Sie, dass es nur die üblichen Anwendungsfälle abdeckt).

Es gibt zwei häufige Anwendungsfälle in Scala mit implicit .

• Verwendung für eine Variable
• Verwendung für eine Funktion

Beispiele sind folgende

Verwendung für eine Variable . Wie Sie sehen können, wenn die implicit Schlüsselwort in der letzten Parameterliste verwendet wird, wird die nächstgelegene Variable verwendet.

// Here I define a class and initiated an instance of this class
case class Person(val name: String)
val charles: Person = Person("Charles")

// Here I define a function
def greeting(words: String)(implicit person: Person) = person match {
  case Person(name: String) if name != "" => s"$name, $words"
    case _ => "$words"
}

greeting("Good morning") // Charles, Good moring

val charles: Person = Person("")
greeting("Good morning") // Good moring

Verwendung für eine Funktion . Wie Sie sehen können, wenn die implicit für die Funktion verwendet wird, wird die nächstliegende Typumwandlungsmethode verwendet.

val num = 10 // num: Int (of course)

// Here I define a implicit function
implicit def intToString(num: Int) = s"$num -- I am a String now!"

val num = 10 // num: Int (of course). Nothing happens yet.. Compiler believes you want 10 to be an Int

// Util...
val num: String = 10 // Compiler trust you first, and it thinks you have `implicitly` told it that you had a way to covert the type from Int to String, which the function `intToString` can do!
// So num is now actually "10 -- I am a String now!"
// console will print this -> val num: String = 10 -- I am a String now!

Ich hoffe, dies kann helfen.