Niejawne definicje, zwłaszcza konwersje.
Na przykład załóżmy, że funkcja, która sformatuje ciąg wejściowy tak, aby pasował do rozmiaru, zastępując jego środek znakiem „...”:
def sizeBoundedString(s: String, n: Int): String = {
if (n < 5 && n < s.length) throw new IllegalArgumentException
if (s.length > n) {
val trailLength = ((n - 3) / 2) min 3
val headLength = n - 3 - trailLength
s.substring(0, headLength)+"..."+s.substring(s.length - trailLength, s.length)
} else s
}
Możesz tego użyć z dowolnym ciągiem i oczywiście użyć metody toString do konwersji wszystkiego. Ale możesz też napisać to tak:
def sizeBoundedString[T](s: T, n: Int)(implicit toStr: T => String): String = {
if (n < 5 && n < s.length) throw new IllegalArgumentException
if (s.length > n) {
val trailLength = ((n - 3) / 2) min 3
val headLength = n - 3 - trailLength
s.substring(0, headLength)+"..."+s.substring(s.length - trailLength, s.length)
} else s
}
Następnie możesz przejść zajęcia innego typu, wykonując następujące czynności:
implicit def double2String(d: Double) = d.toString
Teraz możesz wywołać tę funkcję, przekazując double:
sizeBoundedString(12345.12345D, 8)
Ostatni argument jest niejawny i jest przekazywany automatycznie z powodu niejawnej deklaracji. Ponadto "s" jest istnieniem traktowane jak String wewnątrz sizeBoundedString, ponieważ następuje niejawna konwersja z niego na String.
Implikacje tego typu są lepiej zdefiniowane dla nietypowych typów, aby uniknąć nieoczekiwanych konwersji. Możesz również jawnie przekazać konwersję i nadal będzie ona niejawnie używana wewnątrz sizeBoundedString:
sizeBoundedString(1234567890L, 8)((l : Long) => l.toString)
Możesz również mieć wiele niejawnych argumentów, ale wtedy musisz albo przekazać je wszystkie, albo nie przekazywać żadnego z nich. Istnieje również składnia skrótów dla niejawnych konwersji:
def sizeBoundedString[T <% String](s: T, n: Int): String = {
if (n < 5 && n < s.length) throw new IllegalArgumentException
if (s.length > n) {
val trailLength = ((n - 3) / 2) min 3
val headLength = n - 3 - trailLength
s.substring(0, headLength)+"..."+s.substring(s.length - trailLength, s.length)
} else s
}
To jest używane dokładnie w ten sam sposób.
Implikacje mogą mieć dowolną wartość. Można ich użyć na przykład do ukrycia informacji bibliotecznych. Weźmy na przykład następujący przykład:
case class Daemon(name: String) {
def log(msg: String) = println(name+": "+msg)
}
object DefaultDaemon extends Daemon("Default")
trait Logger {
private var logd: Option[Daemon] = None
implicit def daemon: Daemon = logd getOrElse DefaultDaemon
def logTo(daemon: Daemon) =
if (logd == None) logd = Some(daemon)
else throw new IllegalArgumentException
def log(msg: String)(implicit daemon: Daemon) = daemon.log(msg)
}
class X extends Logger {
logTo(Daemon("X Daemon"))
def f = {
log("f called")
println("Stuff")
}
def g = {
log("g called")(DefaultDaemon)
}
}
class Y extends Logger {
def f = {
log("f called")
println("Stuff")
}
}
W tym przykładzie wywołanie „f” w obiekcie Y spowoduje wysłanie dziennika do demona domyślnego, a na instancji X do demona Daemon X. Ale wywołanie g na instancji X wyśle dziennik do jawnie podanego DefaultDaemon.
Chociaż ten prosty przykład można ponownie napisać z przeciążeniem i stanem prywatnym, implicity nie wymagają stanu prywatnego i można je umieścić w kontekście za pomocą importu.