स्काला को स्पष्ट वापसी प्रकार के लिए कार्यों की आवश्यकता क्यों है?

Question

मैंने हाल ही में स्काला में प्रोग्राम करना सीखना शुरू किया, और यह अब तक मजेदार रहा है। मैं वास्तव में किसी अन्य फ़ंक्शन के भीतर फ़ंक्शन घोषित करने की क्षमता पसंद करता हूं जो बस सहज ज्ञान युक्त चीज़ लगती है।

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

कार्यों पर स्पष्ट वापसी प्रकार की घोषणा की यह आवश्यकता, मुझे जावा और सी ++ जैसी भाषाओं के लिए परेशान नहीं करती है। जावा और सी ++ में पुनरावृत्ति, जब वे हुए, अक्सर 2 से 3 कार्यों के साथ निपटा गया था अधिकतम। स्केला की तरह कभी भी कई कार्य एक साथ नहीं होते हैं।

इसलिए मुझे लगता है कि मैं सोच रहा हूं कि क्या एक अच्छा कारण है कि स्काला को स्पष्ट रिटर्न प्रकार वाले कार्यों की आवश्यकता होनी चाहिए?

Comments

ऐसा नहीं है - और मैं यह देखने में विफल हूं कि अगर यह हुआ तो यह समस्या क्यों होगी।

— कीथ थॉम्पसन

मुझे लगा कि यह किया है। क्या स्काला में ऐसे मामले हैं जहां किसी फ़ंक्शन के लिए वापसी प्रकार वास्तव में अस्पष्ट है?

— कचरा संग्रह

Answer 1

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

इसका मतलब है कि इस तरह एक समारोह:

def fortuneCookieJoke(message: String) = message + " in bed."

वापसी प्रकार की आवश्यकता नहीं है, क्योंकि स्कैला संकलक स्पष्ट रूप से देख सकता है, तर्क चर का उपयोग किए बिना या विधि के मापदंडों के अलावा किसी अन्य चीज को देखने के बिना, कि वापसी प्रकार होना चाहिए String।

दूसरी ओर, इस तरह एक समारोह:

def mapInts(f: (Int) => Int, l: List[Int]) = l match {
  case Nil => Nil
  case x :: xs => f(x) :: mapInts(f, xs)
}

एक संकलन-समय त्रुटि का कारण होगा, क्योंकि स्केल कंपाइलर लुकहेड या लॉजिक चर का उपयोग किए बिना नहीं देख सकता है, वास्तव में क्या प्रकार mapIntsहै। सबसे यह कह सकता है, अगर यह पर्याप्त स्मार्ट था, तो यह है कि वापसी प्रकार का एक प्रकार है List[Nothing], क्योंकि Nilवह उस प्रकार का है। वापसी के प्रकार को सही ढंग से निर्धारित करने के लिए यह पर्याप्त जानकारी के पास कहीं भी नहीं देता है mapInts।

कृपया ध्यान दें कि यह स्काला के लिए विशिष्ट है, और यह कि अन्य सांख्यिकीय रूप से टाइप की जाने वाली भाषाएँ हैं (मिरांडा / हास्केल / स्वच्छ परिवार, अधिकांश एमएल परिवार, और कुछ बिखरे हुए अन्य) जो बहुत अधिक व्यापक और सक्षम प्रकार के इंजेक्शन एल्गोरिदम का उपयोग करते हैं स्कैला उपयोग की तुलना में। इसके अलावा, ध्यान रखें कि यह पूरी तरह से स्काला की गलती नहीं है; नाममात्र उपप्रकार और पूरे-मॉड्यूल प्रकार का अनुमान मूल रूप से एक-दूसरे के साथ अंतर पर है, और स्काला के डिजाइनरों ने जावा संगतता के लिए पहले वाले को पसंद करने का फैसला किया, जबकि "शुद्ध" सांख्यिकीय रूप से टाइप की गई कार्यात्मक भाषाएं ज्यादातर के साथ डिजाइन की गई थीं। मन में विपरीत विकल्प।

Comments

दरअसल, समस्या इतनी व्यापक नहीं है कि एक अधिक व्यापक प्रकार की अनुमान लगाने वाली एल्गोरिथ्म हो। यह एक अधिक व्यापक प्रकार की गणना एल्गोरिथ्म का पता लगा रहा है, जबकि वर्तमान स्काला संकलक में त्रुटि संदेशों की उच्च गुणवत्ता को ध्यान में रखते हुए ।

— जॉर्ग डब्ल्यू मित्तग

क्या case Nilवास्तव में खाली होना सही रिटर्न नहीं होगा List[Int]()? जिस स्थिति में एक पर्याप्त स्मार्ट कंपाइलर यह पता लगा सकता है। यह सब शैतान का वकील खेल रहा है, हालांकि मुझे लगता है।

— KChaloux