Ad esempio, come posso scrivere un'espressione cui la seguente è implicitamente applicato:In che modo è possibile utilizzare impliciti con più input in Scala?
implicit def intsToString(x: Int, y: Int) = "test"
val s: String = ... //?
Grazie
Funzioni implicite di un argomento vengono utilizzati per convertire automaticamente i valori per un tipo previsto. Questi sono noti come viste implicite. Con due argomenti, non funziona o ha senso.
si potrebbe applicare una vista implicito ad una TupleN:
implicit def intsToString(xy: (Int, Int)) = "test"
val s: String = (1, 2)
È anche possibile contrassegnare la lista dei parametri finale di qualsiasi funzione implicita.
def intsToString(implicit x: Int, y: Int) = "test"
implicit val i = 0
val s: String = intsToString
Oppure, la combinazione di questi due usi di implicit:
implicit def intsToString(implicit x: Int, y: Int) = "test"
implicit val i = 0
val s: String = implicitly[String]
Tuttavia non è davvero utile in questo caso.
UPDATE
di approfondire il commento di Martin, questo è possibile.
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]
risposta di Jason ci rimette un caso molto importante: una funzione implicita con più argomenti in cui tutti tranne il primo sono impliciti ... questo richiede due liste di parametri, ma che non sembra essere fuori portata data il modo in cui la domanda è stata espressa.
Ecco un esempio di una conversione implicita che prende due argomenti,
case 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
di campionamento della sessione REPL,
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
Ti implica (:-)) che il mio def originale (che non lo fa avere una lista di parametri implicita) non può essere invocato implicitamente? (Ciò significherebbe che la parola chiave "implicita" è completamente priva di significato nel mio esempio - se nessun codice potrebbe mai osservare una differenza). È davvero così? O è inteso come una risposta parziale, nel senso di "hey, almeno questi casi funzionano"? –
corretto. So di conoscere il modo in cui questo potrebbe essere invocato. Un avviso del compilatore potrebbe essere utile per comunicare questo fatto. – retronym
La funzione originale non può essere utilizzata come conversione implicita, in quanto richiede due parametri. Tuttavia, può ancora essere utilizzato come argomento implicito per un altro metodo. Quindi il modificatore "implicito" ha un significato utile qui. –