Implicit Conversions and Implicit Parameters: Two sides of the same coinīefore throwing ourselves into the sea of the implicit context, it would be nice to make an stop and think about the relation between the two, so seemingly different, implicit tools.īeing Scala a language with such a functional programming load, its functions can be considered values. It is worth of mentioning that the compiler will try those implicit actual parameters (implicit values) which are of the same type than the one required by the formal parameter. The value identifier, its name in the program, doesn’t make any different for the compiler, however it is desirable to follow the same naming rules than any other identifier.
#SCALA IMPLICIT SIMULATOR#
In a physics simulator for different planets, wouldn’t it be uncomfortable having to explicitly pass the gravitational constant to each calculation method? Why not make it an implicit parameter with a value when working on Earth an another when working on Mars? This observation drives to to concept of implicit context, again! Implicit values are hugely used to express contexts.
G(41,1)(100)//will return 42 because of the higher value for 'base' Be called without any actual parameter:ĭef g(x: Int, y: Int)(implicit base: Int): Int = (x+y)%base
Implicit val v: Int = 42 //Implicit value (implicit actual param) Any parameter within this list will be therefore considered implicit which means that can be potentially provided by an implicit value within the function call context (again this term! It’s claiming its own sub-section here!) Any function implicit parameter must be in the last parameter list and this list must be marked as implicit. The concept behind implicit parameters is simple: A method (or function) parameter which can be omitted when calling the method.Īs any Scala developer should know, it allows the declaration of functions or methods with 0, 1 or more than 1 parameter lists (this last case is, in fact, the way the language enables currying). Warning Keep in mind that this rule does NOT mean that objects of type T will be also seen as elements of type S but that the corresponding conversion (implemented as a function from T to S) will be applied. so it is translated to: Double dval = conv(a).vįinally, A elements become also valid actual parameters for formal parameters of type B: def f(x: B): Double = x.m.size * x.vį(a) = f(conv(a)) Rule of thumb Given a context containing an implicit conversion from T to S, you can use any element of type T ( source type) as if it were of type S ( target type). This also applies to attribute accesses as well as method calls: Double dval = a.v // A doesn't have a v attribute, but B does. Ok, but just defining a function doesn’t imply that all places where S is expected will be also be able to receive a parameter of type T. Yes, functions! A conversion is just a function from T to S def conversion(x: T): S = ? What is then the most obvious Scala language tool to describe conversions from a type to another? The straight line is the shortest path from one point to another, similarly the shortest path from a type to another is a function. Therefore, there is one type of implicit value for each kind of element above: Implicit conversions and implicit parameters.
#SCALA IMPLICIT CODE#
In essence, implicit values are no more than a tool for providing the compiler with a way to continue when the code it is compiling lacks some elements which should had been explicitly specified. Meeting the implicit family: Implicit Parameters and Implicit Conversions
#SCALA IMPLICIT FULL#
Its content isn’t 100% original, it is just a tourist guide through this full of marvels, and sometimes dangerous, code jungle.Īs most of those monstrous things that make us shiver, implicit values are mostly harmless once you get to know them. This post pretends to shed some light on the use of implicit values. For new comers, as well as for relatively experienced Scala users, they can become a galaxy of confusions and pitfalls derived from the fact that the use of implicit values imply the compiler making decisions not obviously described in the code and following a set of rules with some unexpected results. But their most important feature is that they offer a way to make your libraries functionality extendible without having to change their code nor needing to distribute it.Ī great power comes with a great responsibility however. When used correctly, they reduce the verbosity of Scala programs thus providing easy to read code. Implicit parameters and conversions are powerful tools in Scala increasingly used to develop concise, versatile tools such as DSLs, APIs, libraries…
0 kommentar(er)
