डॉट्टी में गोल्फ के लिए टिप्स

Question

आप में गोल्फ के लिए सामान्य क्या सुझावों की क्या ज़रूरत है Dotty ? मैं उन विचारों की तलाश कर रहा हूं जो सामान्य तौर पर कोड गोल्फ की समस्याओं पर लागू हो सकते हैं जो कम से कम कुछ हद तक डॉट्टी के लिए विशिष्ट हैं (उदाहरण के लिए "टिप्पणियां हटाएं" एक उत्तर नहीं है)। कृपया प्रति उत्तर एक टिप पोस्ट करें।

स्काला में गोल्फिंग के लिए टिप्स भी देखें

Answer 1

पैरामीटर अनप्लगिंग का उपयोग करें

पैरामीटर अनप्लगिंग आपको एकल टपल को इनपुट के रूप में स्वीकार करने वाले फ़ंक्शन लिखने की अनुमति देता है जैसे कि वे 2 पैरामीटर को स्वीकार करने वाले फ़ंक्शन थे। मूल रूप से, आप इन्हें बदल सकते हैं

list.map{case(a,b)=>a+b}
//and
list.map{case(a,b)=>Seq(a,b)}
//or
list.map(t=>t._1+t._2)
//and
list.map(t=>Seq(t._1,t._2))

इसके साथ, जो छोटा और अधिक सुंदर दोनों है।

list.map(_+_)
//and
list.map(Seq(_,_))

Answer 2

@Main और toplevel फ़ंक्शन का उपयोग करें

यदि आपको एक पूर्ण कार्यक्रम बनाने की आवश्यकता है, तो एक @mainमुख्य मोड पर एनोटेशन का उपयोग करें ।

@main def main={code}

यह इन 2 दृष्टिकोणों से बहुत छोटा है:

object M extends App{code}
object M{def main(a:Array[String])={code}}

Answer 3

संख्यात्मक साहित्य

अब आप किसी भी उपयोगकर्ता द्वारा परिभाषित प्रकार के लिए एक नंबर शाब्दिक लिख सकते हैं FromDigits, जैसे कि विशेषता के दिए गए / निहित उदाहरण जैसे BigIntऔर BigDecimal।

स्कैला 2 में, 9,999,999,999,999,999 की संख्या को स्वीकार करने वाले फ़ंक्शन BigIntको पास करने के लिए BigInt("9999999999999999"), आपको उपयोग करना होगा , लेकिन अब आप सीधे 9999999999999999आवेदन पद्धति या कंस्ट्रक्टर का उपयोग किए बिना स्पष्ट रूप से कह सकते हैं ।

आप किसी भी सामान्य संख्या के शाब्दिक की तरह अंडरस्कोर, वैज्ञानिक संकेतन, हेक्स इत्यादि का भी उपयोग कर सकते हैं, जब तक FromDigitsकि उस प्रकार का उदाहरण उस संकेतन का समर्थन करता है, निश्चित रूप से। दोनों BigIntऔर BigDecimalअंडरस्कोर से ठीक हैं, लेकिन केवल BigIntहेक्स की अनुमति देता है, और केवल BigDecimal(दशमलव के साथ) वैज्ञानिक अंकन अनुमति देता है।

Answer 4

वैकल्पिक ब्रेसिज़

मैच के भावों में, कम से कम, आप इंडेंटेशन-आधारित सिंटैक्स का उपयोग करके एक बाइट को बचा सकते हैं।

a match
case b=>c
case d=>e

27 बाइट्स है, जबकि नीचे कोड 28 है।

a match{case b=>c case d=>e}

साइड नोट के रूप में, matchयह भी विशेष उपचार हो जाता है जब यह चेनिंग की बात आती है। निम्नलिखित स्केल 2 कोड:

("foo"match{case x=>x})match{case x=>x}

अब कोष्ठकों के बिना लिखा जा सकता है:

"foo"match{case x=>x}match{case x=>x}

Answer 5

निर्माता अनुप्रयोगों केnew साथ बाहर छोड़ दें

आप कंस्ट्रक्टर को उपयोग कर सकते हैं new(जैसे कोटलिन), सभी वर्गों के साथ ऐसा व्यवहार करना, जैसे कि applyउनके साथियों में विधियाँ हों। यह 4 बाइट्स बचाता है हर बार जब आप कुछ पल, new Foo()बस के बाद से हो जाता है Foo()।

यह गिवेन पर भी लागू होता है (हालाँकि आपको कोड गोल्फ के लिए शायद ही कभी उनकी आवश्यकता होती है):

given foo as Foo=new Foo() //bad
given foo as Foo=Foo()     //better
given foo as Foo           //great

Answer 6

पैटर्न मिलान से मेल खाने वाले पुनरावर्ती कार्यों के लिए मिलान प्रकारों का उपयोग करें

एक मिलान प्रकार के साथ एक टाइपेलिया बनाना कभी-कभी एक उचित फ़ंक्शन का उपयोग करने से कम होता है। उदाहरण के लिए, केआई कैलकुलस के कार्यान्वयन (वास्तविक चीज़ नहीं) को लें। प्रकार की आवश्यकता नहीं है :Any, इसलिए आप सभी में 7 बाइट्स बचाते हैं ( type1 बाइट से अधिक है def)।

//A normal function
def r(t:Any):Any=t match{case(('K',x),y)=>r(x)case('I',x)=>r(x)case t=>t}
//With match types
type R[T]=T match{case(('K',x),y)=>R[x]case('I',x)=>R[x]case _=>T}

जाहिर है, इस विशेष उदाहरण में, आप ऑटो-टैपिंग, ->पैटर्न-मिलान फ़ंक्शन शाब्दिक, आदि का उपयोग कर सकते हैं ताकि कम को कम किया जा सके, लेकिन यह सिर्फ एक मामला है। जब आप टुपल्स के साथ काम नहीं कर रहे होते हैं, या रिटर्न प्रकार बस की तुलना में अधिक जटिल होता है Any, या आपके पास कई पैरामीटर होते हैं, तो यह टिप अधिक उपयोगी हो जाती है।

Answer 7

न्यू कंट्रोल सिंटेक्स

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

for((x,y,z)<-Seq((1,2,3),(3,4,5));y<-"foo")yield y+x  //Old-style syntax
for(x,y,z)<-Seq((1,2,3),(3,4,5));y<-"foo"yield y+x    //New control syntax

यह पैरामीटर अनूपलिंग की तरह कुछ अन्य चीजों के रूप में उपयोगी नहीं है, लेकिन मैं अक्सर खुद को फ़ंक्शन कॉल जैसे , f(foo)या Seq(1,2)जो कोष्ठक में समाप्त होता है, के लिए समझ के लिए उपयोग कर पाता हूं ।

इसे स्कैस्टी में चलाकर देखें ।