डिफ़ॉल्ट सामान्य मूल्य

Question

मैं एक वर्ग है कहते हैं:

class SomeClass[+A <: AnyRef, +B <: Any] 

यह निर्दिष्ट करने के लिए मैं हमेशा बहुत सामान्य मापदंडों का प्रकार निर्दिष्ट करना होगा। अर्थात। विधि पैरामीटर प्रकार के रूप में अपना सबसे सामान्य संस्करण निर्दिष्ट करने के लिए मुझे इसे तुरंत चालू करने के लिए def someMethod(param1: SomeClass[AnyRef, Any]) या new SomeClass[AnyRef, Any] करना होगा। जब यह जटिल जेनेरिक जटिल जटिल प्रकारों की बात आती है तो यह एक बड़ा दर्द बन जाता है।

क्या [AnyRef, Any] हिस्सा बनाने का कोई तरीका है जब मैं सामान्य जानकारी प्रदान नहीं करता? उदाहरण के लिए def someMethod(param1: SomeClass)?

क्या कोई तरीका है _ इस समस्या को हल करने में मेरी मदद कर सकता है और कैसे?

पीएस मूल रूप से प्रश्न को स्पष्ट रूप से बताते हुए मैं क्षमा चाहता हूं।

Answer 1

मेरी टिप्पणी में सुझाव दिया, कुछ इस तरह कर रही है कुछ टाइपिंग बचा सकते हैं और बिल्कुल स्पष्ट है के रूप में:

type SomeClassAny = SomeClass[AnyRef, Any] 

Answer 2

इस बारे में कैसे?

scala> :paste 
// Entering paste mode (ctrl-D to finish) 

class SomeClass[+A <: AnyRef] 

object SomeClass { 
    def apply() = new SomeClass[AnyRef] 
} 

// Exiting paste mode, now interpreting. 

defined class SomeClass 
defined module SomeClass 

scala> SomeClass() 
res47: SomeClass[AnyRef] = SomeClass@4f63b5 

संपादित करें:

मुझे लगता है कि आप डिफ़ॉल्ट तर्क की तरह कुछ चाहते हैं, लेकिन प्रकार के स्तर पर। दुर्भाग्य से स्कैला में ऐसी कोई सुविधा नहीं है। आप @hyhnhjl द्वारा सुझाए गए प्रकार के उपनाम का उपयोग कर सकते हैं। यह मेरे लिए आपकी सबसे अच्छी शर्त लगता है।

Answer 3

आमतौर पर इसे कन्स्ट्रक्टर पैरामीटर के प्रकार से अनुमानित किया जा सकता है, लेकिन यदि निर्माता कोई पैरामीटर नहीं लेता है, तो आपको स्पष्ट रूप से प्रकार निर्दिष्ट करना होगा। बेशक, जैसा कि गायबफैक्टर ने बताया, आप हमेशा कुछ टाइपिंग सहेजने के लिए एक विधि लिख सकते हैं।

Answer 4

यदि आप वास्तव में देखभाल पर इस बात के बारे में क्या सोचते हैं, तो आप इसे [_, _] के साथ parametrize कर सकते हैं। उदाहरण

val thing = new SomeClass[_, _]() 

या

def thingDoer(sc: SomeClass[_, _]) { /* Stuff */ } 

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

public void thingThatTakesAMapList(List<? extends Map> mapList) { /* Whatever */ } 

इस स्काला कोड

def thingThatTakesAMapList(mapList: List[_ <: Map[_, _]]) { /* Some incredibly wild subroutine */ } 

के रूप में भी एक ही है, यह सूची के बीच distinguishment ध्यान देने योग्य है [कोई] और सूची [_] ... बहुत सूक्ष्म। यह कहना है कि पूर्व किसी की सूची है, और उत्तरार्द्ध [मुझे नहीं पता/देखभाल] की एक सूची है। _ किसी भी से अलग है, हालांकि।उदाहरण के लिए, अगर आप इस हस्ताक्षर के साथ एक वर्ग था

class SillyClass[T <: Map[_, _]] 

यह करने के लिए मान्य नहीं होगा इस

val thing = new SillyClass[Any]() 

जबकि यह आप इस

val thing = new SillyClass[HashMap[_, _]]() 

करने के लिए मान्य हो सकता है

और, यदि किसी फ़ंक्शन ने पैरामीटर के रूप में एक SillyClass लिया, तो आप

लिख सकते हैं

और सुनिश्चित करें कि एससी किसी भी प्रकार पर parametrized जा रहा है; यह मानचित्र के कुछ अज्ञात सबक्लास पर parametrized है [_, _]। यही कहना है कि अंडरस्कोर प्लेसहोल्डर है, लेकिन इसके लिए अभी भी आवश्यक है कि वैध प्रकार पैरामीटर इसके स्थान पर मौजूद हों। तो, यह सब अच्छा है और सब कुछ ... मैं विशेष रूप से इसका उपयोग करने की सलाह नहीं देता हूं। अगर आपको कुछ करने की ज़रूरत है ... वाइल्डकार्ड-वाई, या बस टाइप पैरामीटर की परवाह नहीं है, हालांकि, यह विचार करने का एक अच्छा विकल्प है।