विशिष्ट परिभाषाएँ, विशेष रूप से रूपांतरण।
उदाहरण के लिए, एक फ़ंक्शन मानें जो एक इनपुट स्ट्रिंग को एक आकार में फिट करने के लिए प्रारूपित करेगा, इसके बीच के स्थान को "..." के साथ बदलकर
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
}
आप किसी भी स्ट्रिंग के साथ उपयोग कर सकते हैं, और, ज़ाहिर है, कुछ भी परिवर्तित करने के लिए स्ट्रीटिंग विधि का उपयोग करें। लेकिन आप इसे इस तरह भी लिख सकते हैं:
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
}
और फिर, आप ऐसा करके अन्य प्रकार की कक्षाएं पास कर सकते हैं:
implicit def double2String(d: Double) = d.toString
अब आप उस फ़ंक्शन को डबल पास कर सकते हैं:
sizeBoundedString(12345.12345D, 8)
अंतिम तर्क निहित है, और निहित डे घोषणा के कारण स्वचालित रूप से पारित किया जा रहा है। इसके अलावा, "एस" का आकार के अंदर स्ट्रिंग की तरह व्यवहार किया जा रहा हैबाउंडेडस्ट्रिंग क्योंकि इसमें स्ट्रिंग से एक अंतर्निहित रूपांतरण है।
अप्रत्याशित रूपांतरणों से बचने के लिए असामान्य प्रकारों के लिए इस प्रकार के इम्प्लाइक बेहतर परिभाषित हैं। आप एक रूपांतरण को भी आसानी से पास कर सकते हैं, और यह अभी भी आकार के अंदर उपयोग किया जाएगा।
sizeBoundedString(1234567890L, 8)((l : Long) => l.toString)
आपके पास कई निहित तर्क भी हो सकते हैं, लेकिन फिर आपको या तो उन सभी को पारित करना होगा, या उनमें से किसी को भी पारित नहीं करना होगा। निहित रूपांतरण के लिए एक शॉर्टकट सिंटैक्स भी है:
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
}
यह बिल्कुल उसी तरह उपयोग किया जाता है।
Implicits का कोई भी मूल्य हो सकता है। उदाहरण के लिए, लाइब्रेरी जानकारी को छिपाने के लिए उनका उपयोग किया जा सकता है। उदाहरण के लिए, निम्नलिखित उदाहरण लें:
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")
}
}
इस उदाहरण में, वाई ऑब्जेक्ट में "एफ" कॉल करने पर लॉग को डिफ़ॉल्ट डेमॉन में भेज दिया जाएगा, और एक्स के डेमन एक्स डेमन को इंस्टेंस पर। लेकिन एक्स के एक उदाहरण पर जी कॉल करने से लॉग को स्पष्ट रूप से दिए गए डिफाल्डमन में भेज दिया जाएगा।
हालांकि इस सरल उदाहरण को अधिभार और निजी राज्य के साथ फिर से लिखा जा सकता है, लेकिन इंपीटिस को निजी राज्य की आवश्यकता नहीं है, और आयात के संदर्भ में लाया जा सकता है।