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

Question

मैं स्काला में एक सरल 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) 
} 

मैं जानता हूँ कि यह, वैसे भी काम नहीं करेगा क्योंकि टी एक प्रकार है जो के लिए toFloat परिभाषित नहीं है हो सकता है, लेकिन संकलक त्रुटि मैं मिलता है:

no type parameters allowed here

यह सिर्फ unsupp है Scala में Orted? यदि हां, तो क्यों, और इस के आसपास जाने का कोई आसान तरीका है?

Answer 1

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

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

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 typeclass का उपयोग किया है एक सामान्य toFloat विधि प्राप्त करने के लिए।

Answer 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 ...? 

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

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