Zum Beispiel: Wie kann ich einen Ausdruck schreiben, wo die folgenden implizit angewandt:Wie können implicits mit mehreren Eingängen in Scala verwendet werden?
implicit def intsToString(x: Int, y: Int) = "test"
val s: String = ... //?
Dank
Implizite Funktionen eines Argument verwendet werden, um automatisch Werte zu einem erwarteten Typ zu umwandeln. Diese werden als Implizite Ansichten bezeichnet. Mit zwei Argumenten funktioniert es nicht oder ergibt keinen Sinn.
Sie könnten einen impliziten Hinblick auf ein TupleN gelten:
implicit def intsToString(xy: (Int, Int)) = "test"
val s: String = (1, 2)
Sie können die letzte Parameterliste einer Funktion als implizit auch markieren.
def intsToString(implicit x: Int, y: Int) = "test"
implicit val i = 0
val s: String = intsToString
Oder diese beiden Verwendungen von implicit Kombination:
implicit def intsToString(implicit x: Int, y: Int) = "test"
implicit val i = 0
val s: String = implicitly[String]
jedoch in diesem Fall nicht wirklich nützlich ist.
UPDATE
auf Martins Kommentar zu erarbeiten, ist dies möglich.
implicit def foo(a: Int, b: Int) = 0
// ETA expansion results in:
// implicit val fooFunction: (Int, Int) => Int = (a, b) => foo(a, b)
implicitly[(Int, Int) => Int]
Jasons Antwort verfehlt einen sehr wichtigen Fall aus: eine implizite Funktion mit mehreren Argumenten, wo alle, aber die ersten implizit sind ... diese zwei Parameterlisten erfordert, aber das scheint nicht gegeben den Gültigkeitsbereich zu sein die Art, wie die Frage geäußert wurde.
Hier ist ein Beispiel für eine implizite Konvertierung, die
zwei Argumente nimmtcase class Foo(s : String)
case class Bar(i : Int)
implicit val defaultBar = Bar(23)
implicit def fooIsInt(f : Foo)(implicit b : Bar) = f.s.length+b.i
Probe REPL Sitzung
scala> case class Foo(s : String)
defined class Foo
scala> case class Bar(i : Int)
defined class Bar
scala> implicit val defaultBar = Bar(23)
defaultBar: Bar = Bar(23)
scala> implicit def fooIsInt(f : Foo)(implicit b : Bar) = f.s.length+b.i
fooIsInt: (f: Foo)(implicit b: Bar)Int
scala> val i : Int = Foo("wibble")
i: Int = 29
Haben Sie (:-)), dass meine ursprüngliche def implizieren (was nicht haben implizite Parameterliste) kann nicht implizit aufgerufen werden? (Das würde bedeuten, dass das "implizite" Schlüsselwort in meinem Beispiel völlig bedeutungslos ist - wenn kein Code jemals einen Unterschied beobachten könnte). Ist das wirklich so? Oder soll das eine Teilantwort sein, im Sinne von "Hey, zumindest funktionieren diese Fälle?" –
Korrigieren. Ich kenne den bekannten Weg in der aktuellen Sprache, dass dies aufgerufen werden könnte. Eine Compiler-Warnung könnte hilfreich sein, um diese Tatsache zu kommunizieren. – retronym
Die ursprüngliche Funktion kann nicht als implizite Konvertierung verwendet werden, da sie zwei Parameter benötigt. Es kann jedoch immer noch als implizites Argument für eine andere Methode verwendet werden. Der "implizite" Modifikator hat hier also eine nützliche Bedeutung. –