In scala fonctionne implicitement comme :
Convertisseur
Injecteur de valeur de paramètre
Il existe 3 types d'utilisation implicite
Conversion de type implicite : il convertit l'affectation produisant l'erreur en type prévu
val x: String = "1"
val y: Int = x
La chaîne n'est pas le sous-type d'Int , donc l'erreur se produit à la ligne 2. Pour résoudre l'erreur, le compilateur recherchera une telle méthode dans la portée qui a un mot clé implicite et prend une chaîne comme argument et renvoie un Int .
alors
implicit def z(a:String):Int = 2
val x :String = "1"
val y:Int = x // compiler will use z here like val y:Int=z(x)
println(y) // result 2 & no error!
Conversion de récepteur implicite : Nous avons généralement par les propriétés de l'objet d'appel du récepteur, par exemple. méthodes ou variables. Ainsi, pour appeler une propriété par un récepteur, la propriété doit être membre de la classe / de l'objet de ce récepteur.
class Mahadi{
val haveCar:String ="BMW"
}
class Johnny{
val haveTv:String = "Sony"
}
val mahadi = new Mahadi
mahadi.haveTv // Error happening
Ici, mahadi.haveTv produira une erreur. Parce que le compilateur scala va d' abord chercher la haveTv propriété à Mahadi récepteur. Il ne trouvera pas. Deuxièmement, il recherchera une méthode dans la portée ayant un mot clé implicite qui prend l' objet Mahadi comme argument et renvoie l' objet Johnny . Mais il n'a pas ici. Cela créera donc une erreur . Mais ce qui suit est correct.
class Mahadi{
val haveCar:String ="BMW"
}
class Johnny{
val haveTv:String = "Sony"
}
val mahadi = new Mahadi
implicit def z(a:Mahadi):Johnny = new Johnny
mahadi.haveTv // compiler will use z here like new Johnny().haveTv
println(mahadi.haveTv)// result Sony & no error
Injection implicite de paramètres : si nous appelons une méthode et ne transmettons pas sa valeur de paramètre, cela provoquera une erreur. Le compilateur scala fonctionne comme ceci - le premier essaiera de transmettre la valeur, mais il n'obtiendra aucune valeur directe pour le paramètre.
def x(a:Int)= a
x // ERROR happening
Deuxièmement, si le paramètre a un mot clé implicite, il recherchera tout val dans la portée qui a le même type de valeur. Sinon, cela provoquera une erreur.
def x(implicit a:Int)= a
x // error happening here
Pour résoudre ce problème, le compilateur recherchera une valeur implicite ayant le type Int car le paramètre a a un mot clé implicite .
def x(implicit a:Int)=a
implicit val z:Int =10
x // compiler will use implicit like this x(z)
println(x) // will result 10 & no error.
Un autre exemple:
def l(implicit b:Int)
def x(implicit a:Int)= l(a)
on peut aussi l'écrire comme
def x(implicit a:Int)= l
Parce que l a un paramètre implicite et dans la portée du corps de la méthode x , il existe une variable locale implicite (les paramètres sont des variables locales ) a qui est le paramètre de x , donc dans le corps de la méthode x la valeur de l'argument implicite de la signature de méthode est déposée par la variable locale de la méthode x implicite (paramètre) aimplicitement .
Alors
def x(implicit a:Int)= l
sera dans le compilateur comme celui-ci
def x(implicit a:Int)= l(a)
Un autre exemple:
def c(implicit k:Int):String = k.toString
def x(a:Int => String):String =a
x{
x => c
}
cela provoquera une erreur, car c dans x {x => c} a besoin d'un argument de valeur explicite ou d'une valeur implicite dans la portée .
Nous pouvons donc rendre le paramètre de la fonction littérale explicitement implicite lorsque nous appelons la méthode x
x{
implicit x => c // the compiler will set the parameter of c like this c(x)
}
Cela a été utilisé dans la méthode d'action de Play-Framework
in view folder of app the template is declared like
@()(implicit requestHreader:RequestHeader)
in controller action is like
def index = Action{
implicit request =>
Ok(views.html.formpage())
}
si vous ne mentionnez pas explicitement le paramètre de demande comme implicite, alors vous devez avoir été écrit-
def index = Action{
request =>
Ok(views.html.formpage()(request))
}