स्कैला: लंबी टाइप पैरामीटर सूचियों के साथ कैसे काम करें

Question

लंबी टाइप पैरामीटर सूचियों से निपटने के लिए स्कैला में मैं कौन सी तकनीकों का उपयोग कर सकता हूं?

मैं विभिन्न सिम्युलेटेड वातावरण के साथ विभिन्न प्रकार के गेम चलाने के लिए एक छोटे ढांचे पर काम कर रहा हूं। मैं अपेक्षाकृत सामान्य रूप से ढांचे के कुछ हिस्सों को रखने की कोशिश कर रहा हूं, इसलिए मैं विभिन्न प्रकार के प्रकार जैसे कि पर्यावरण की स्थिति, खेल परिणाम इत्यादि के रूप में पेश कर रहा हूं।

यह सब काफी अच्छी तरह से काम करता है और मैं करता हूं एक प्रकार के सुरक्षित अभी तक सामान्य ढांचे के वांछित लाभ प्राप्त करें। लेकिन प्रकार के हस्ताक्षर उस बिंदु तक उभरे हैं जहां यह कोड को पढ़ने और पुन: सक्रिय करने के लिए कठिन बनाता है, यह काफी बोझिल हो गया है। शीर्ष-स्तरीय सिम्युलेटर के हस्ताक्षर में आठ प्रकार के पैरामीटर हैं और कई प्राथमिक प्रकारों में तीन से पांच हैं। व्यक्तिगत कंपाइलर प्रकार त्रुटियां, क्योंकि वे कक्षा या फ़ंक्शन पैरामीटर के प्रकार सूचीबद्ध करते हैं (जो निश्चित रूप से टाइप-पैरामीटरकृत हैं) नियमित रूप से सौ लाइनों तक चलते हैं।

कभी-कभी, लेकिन बहुत ही कम, मैं प्रकार पैरामीटर को छोड़ सकता हूं, उदा। रचनाकारों पर। लेकिन ज्यादातर मामलों में कम से कम एक प्रकार का अनुमान नहीं लगाया जाता है, इसलिए मैं पूरे प्रकार के हस्ताक्षर को सम्मिलित करना समाप्त करता हूं।

जाहिर है यह आदर्श नहीं है और मैं इस समस्या को हल करने के तरीकों की तलाश में हूं। किसी भी सलाह की सराहना की जाएगी!

Answer 1

उस मामले पर विचार करें जब आपके पास प्रकार के पैरामीटर समूह हैं जो निकट से संबंधित हैं; आप उन्हें तर्क तर्क के रूप में एक साथ पास करते हैं। इस उदाहरण में, यह समूह A और B है।

trait X[A, B, C] { 
    new Y[A, B, Int] {} 
} 

trait Y[A, B, D] { 
    def a: A = sys.error("") 
} 

आप एक प्रकार उर्फ ​​युक्त प्रकार के सदस्यों के साथ एक ही प्रकार के पैरामीटर में इन दो प्रकार के पैकेज कर सकते हैं:

type AB = { type A; type B } 
trait Y[ab <: AB, D] { 
    def a: ab#A = sys.error("") 
} 
trait X[ab <: AB, C] { 
    new Y[ab, C] {} 
} 
new X[{ type A=Int; type B=Int}, String] {} 

Answer 2

दो समाधान दिमाग में आते हैं।

1. प्रकार उपनाम का उपयोग करें।

   scala> class Foo[A, B, C, D, E] 
   defined class Foo 
   
   scala> type Bar[A] = Foo[A, Int, Int, Int, Float] 
   defined type alias Bar 
   
   scala> new Bar[String] 
   res23: Foo[String,Int,Int,Int,Float] = Foo@f590c6 
   

2. उपयोग abstract type members बजाय प्रकार पैरामीटर।

   scala> class Bar { 
       | type A 
       | type B <: AnyVal 
       | type C 
       | } 
   defined class Bar 
   
   scala> new Bar { 
       | type A = String 
       | type B = Int 
       | type C = Int 
       | } 
   res24: Bar{type A = String; type B = Int; type C = Int} = $anon$1@ee1793 
   
   scala> trait Baz { 
       | type A = String 
       | } 
   defined trait Baz 
   
   scala> new Bar with Baz { 
       | type B = Int 
       | type C = String 
       | } 
   res25: Bar with Baz{type B = Int; type C = String} = $anon$1@177c306 
   
   scala> null.asInstanceOf[res25.A] 
   res26: res25.A = null 
   
   scala> implicitly[res25.A =:= String] 
   res27: =:=[res25.A,String] = <function1> 
   

आप हमारे साथ कुछ कोड साझा करने के लिए इतना है कि हम कुछ और विशिष्ट सलाह दे सकते हैं चाहते हो सकता है।