स्कैला सहायक कन्स्ट्रक्टरों में टाइप पैरामीटर क्यों नहीं दिए गए हैं? - टेम्पलेट्स, स्कैला, कन्स्ट्रक्टर

मान लीजिए कि मैं स्काला में एक साधारण 2 डी बिंदु वर्ग को परिभाषित कर रहा हूं, और मैं इसे विभिन्न प्रकारों के साथ बनाने में सक्षम होना चाहता हूं:

class Point(x:Float, y:Float) {
this(x:Double, y:Double) = this(x.toFloat, y.toFloat)
this(x:Int, y:Int) = this(x.toFloat, y.toFloat)
// etc...
}

मैं इसे एक टेम्पलेट का उपयोग करके उबालना चाहता हूं, जैसे:

class Point(x:Float, y:Float) {
this[T](x:T, y:T) = this(x.toFloat, y.toFloat)
}

मुझे पता है कि यह "टी वर्क वैसे भी जीता है, क्योंकि टी एक प्रकार का हो सकता है जिसके लिए कोई भी परिभाषित नहीं है, लेकिन मुझे जो कंपाइलर त्रुटि मिलती है वह है:

यहां किसी प्रकार के मापदंडों की अनुमति नहीं है

क्या यह सिर्फ स्काला में असमर्थित है? यदि हां, तो क्यों, और क्या इसके आसपास कोई सरल तरीका है?

उत्तर:

उत्तर № 1 के लिए 14

स्काला के वर्ग निर्माता (जावा के विपरीत) "टी" प्रकार के मापदंडों को ले सकते हैं, केवल कक्षा ही कर सकते हैं। क्यों स्काला ने यह डिजाइन पसंद किया, मुझे लगता है कि मुख्य कारण सादगी है।

यदि आप एक द्वितीयक "बिल्डर" विधि चाहते हैं, जो सामान्य है, तो ऐसा करने के लिए प्राकृतिक वस्तु इसे साथी वस्तु पर परिभाषित करती है। उदाहरण के लिए,

object Point {
def build[T : Numeric](x: T, y: T) = {
val n = implicitly[Numeric[T]]
new Point(n.toFloat(x), n.toFloat(y))
}
}

class Point(val x:Float, val y:Float)

val p = Point.build(1, 2) // Companion object"s builder
p.x + p.y

यहाँ मैंने "का उपयोग किया है Numeric जेनेरिक पाने के लिए टाइपकास्ट toFloat तरीका।

---

जवाब के लिए 3 № 2

मैं थोड़ी देर के लिए इस के साथ खेला, के रूप में "पास" के रूप में हो रही है ...

class Point(x:Float, y:Float) {
def this[T <: Any { def toFloat: Float }](x:T, y:T) = this(x.toFloat, y.toFloat)
}

... जिसके परिणामस्वरूप "त्रुटि: यहां किसी प्रकार के पैरामीटर की अनुमति नहीं है" (बस पोस्ट के अनुसार) और फिर मुझे एहसास हुआ ...

यदि इनिशलाइज़र टाइप पैरामीटर ले सकता है तो यह क्लास के मापदंडों के साथ अस्पष्ट होगा, यदि कोई हो। ऐसा नहीं है सका "टी भाषा विनिर्देश के बारे में काम किया जाए ... लेकिन यह बहुत कम से कम एक अधिक जटिल मामला है जावा इंटरऑपरेबिलिटी के मुद्दे भी हो सकते हैं।

कल्पना कीजिए:

class Foo[T](x: T) {
def this[X](z: X) = ...
}
new Foo[Int](42) // T is Int? X is ...? Or ...?

व्यक्तिगत रूप से मेरी इच्छा है कि स्काला ने एफिल जैसा पैटर्न (केवल नामांकित निर्माता या "कारखाने के तरीके") का पालन किया, लेकिन अफसोस, कि स्काला नहीं होगा।

हैप्पी कोडिंग

---