Definieren einer Funktion mit mehreren impliziten Argumenten in Scala

94

Wie kann ich eine Funktion mit mehreren impliziten Argumenten definieren?

def myfun(arg:String)(implicit p1: String)(implicit p2:Int)={} // doesn't work

scala

— Ali Salehi
quelle

2

Im Fragentext fragen Sie nach einer Funktion. In Ihrem Code-Snippet haben Sie eine Methode. Fragen Sie nach einer Funktion oder einer Methode?

— Jörg W Mittag

190

Sie müssen alle in einer Parameterliste enthalten sein, und diese Liste muss die letzte sein.

def myfun(arg:String)(implicit p1: String, p2:Int)={}

— fehlender Faktor
quelle

1

Wenn es eine Klasse wäre, wäre die Syntax die Klasse MyClass () (implizites p1: String, implizites p2: Int) {}

— skjagini

2

Es gibt tatsächlich eine Möglichkeit, genau das zu tun, was das OP erfordert. Ein bisschen verworren, aber es funktioniert.

class MyFunPart2(arg: String, /*Not implicit!*/ p1: String) {
  def apply(implicit p2: Int) = {
    println(arg+p1+p2)
    /* otherwise your actual code */
  }
}

def myFun(arg: String)(implicit p1: String): MyFunPart2= {
  new MyFunPart2(arg, p1)
}

implicit val iString= " world! "
implicit val iInt= 2019

myFun("Hello").apply
myFun("Hello")(" my friend! ").apply
myFun("Hello")(" my friend! ")(2020)

//  Output is:
//      Hello world! 2019
//      Hello my friend! 2019
//      Hello my friend! 2020

In Scala 3 (auch bekannt als "Dotty", obwohl dies der Name des Compilers ist) ist es möglich, einen Funktionswert mit impliziten Argumenten direkt zurückzugeben, anstatt ein zusätzliches MyFunPart2- Objekt zurückzugeben. Dies liegt daran, dass Scala 3 "Implizite Funktionen" unterstützt (dh "Parameter implicitness" ist jetzt Teil der Funktionstypen). Mehrere implizite Parameterlisten sind so einfach zu implementieren, dass die Sprache sie möglicherweise direkt unterstützt, obwohl ich nicht sicher bin.

— Mario Rossi
quelle

1

Es gibt einen anderen (IMO einfacher und flexibleren) Weg, um einen ähnlichen Effekt zu erzielen:

// Note the implicit is now a Tuple2
def myFun(arg: String)(implicit p: (String, Int) ): Unit = {
  println(arg + p._1 + p._2)
  /*otherwise your actual code*/
}

// These implicit conversion are able to produce the basic implicit (String,Int) Tuples
implicit def idis(implicit is: String, ii: Int): (String,Int)= (is,ii)
implicit def idi(s: String)(implicit ii: Int): (String,Int)= (s,ii)

// The basic implicit values for both underlying parameters
implicit val iString = " world! "
implicit val iInt = 2019

myFun("Hello")
myFun("Hello")(" my friend! ")
myFun("Hello")(" my friend! ",2020)

// Output is:
//     Hello world! 2019
//     Hello my friend! 2019
//     Hello my friend! 2020

// If we add the following implicit, 
implicit def ids(i: Int)(implicit is: String)= (is,i)

// we can even do
myFun("Hello")(2020)

// , and output is:
//     Hello world! 2020

Die Verwendung eines Tupels als zugrunde liegende Darstellung für die Parameter ist keine gute Idee, da die impliziten Konvertierungen andere Verwendungen beeinträchtigen könnten. Tatsächlich verursachen implizite Konvertierungen in einen Standardtyp (einschließlich Bibliothekstypen) normalerweise Probleme in nicht trivialen Anwendungen. Die Lösung besteht darin, eine dedizierte Fallklasse zu erstellen, die die Parameter anstelle eines Tupels enthält. Ein wichtiger Vorteil ist, dass ihnen Namen gegeben werden könnten, die viel aussagekräftiger sind als _1 und _2.

— Mario Rossi
quelle