शेपलेस में नट प्रकार की सीमा

Question

आकारहीन में, नेट प्रकार एक प्रकार के स्तर पर प्राकृतिक संख्याओं को एनकोड करने का एक तरीका दर्शाता है। यह निश्चित आकार सूचियों के लिए उदाहरण के लिए उपयोग किया जाता है। आप प्रकार के स्तर पर भी गणना कर सकते हैं, उदाहरण के लिए Nतत्वों की एक सूची को Kतत्वों की एक सूची में जोड़ सकते हैं और एक सूची वापस प्राप्त कर सकते हैं जो N+Kतत्वों के संकलन समय पर जाना जाता है ।

क्या यह प्रतिनिधित्व बड़ी संख्याओं का प्रतिनिधित्व करने में सक्षम है, उदाहरण के लिए 1000000या 2 ⁵³ , या यह स्काला संकलक को छोड़ देगा?

Comments

माइल्स की एनई स्काला प्रस्तुति पिछले साल इस प्रश्न को संबोधित करती है, और संक्षिप्त उत्तर यह है कि स्काला में टाइप स्तर पर बड़ी संख्या में प्रतिनिधित्व करना संभव होगा या कम से कम 2.10 में - एकलिंग प्रकार का उपयोग करना , लेकिन यह इसके लायक नहीं हो सकता है । शापलेस 2.0 वर्तमान में अभी भी चर्च एन्कोडिंग का उपयोग करता है, जो आपको संकलक को देने से पहले 1,000 या तो मिल जाएगा।

— ट्रैविस ब्राउन

मैं आज बाद में थोड़ा और संदर्भ के साथ उत्तर लिखने का प्रयास करूंगा। एक तरफ ध्यान दें के रूप में, यह नहीं बहुत कठिन प्रकार सिंगलटन पूर्णांक के साथ काम करने के लिए अगर आप की जरूरत है अपने ब्लॉग पोस्ट बड़ा प्रकार स्तर संख्या देखने के उदाहरण के लिए है यहाँ या निराकार में सिंगलटन कार्यक्षमता ।

— ट्रैविस ब्राउन

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

— करोल एस

@KarolS मेरे पास उस रणनीति का कार्यान्वयन है! और अगर किसी को दिलचस्पी है, तो मैं इसे बेकार में योगदान देने में खुशी महसूस करूंगा, हालांकि यह तब तक बेकार है जब तक कि कोई व्यक्ति stackoverflow.com/questions/31768203/…

— beefyhalo

ऐसा लगता है कि stackoverflow.com/questions/31768203/… हल किया गया है, तो क्या आप कोड का योगदान कर सकते हैं और अपने स्वयं के उत्तर के साथ प्रश्न को बंद कर सकते हैं?

— एंड्री कुबा

Answer 1

मैं खुद एक प्रयास करूंगा। मैं ट्रैविस ब्राउन या माइल्स सबिन से बेहतर जवाब को सहर्ष स्वीकार करूंगा।

वर्तमान में बड़ी संख्या का प्रतिनिधित्व करने के लिए नेट का उपयोग नहीं किया जा सकता है

नेट के वर्तमान कार्यान्वयन में, मान नेस्टेड आकारहीन की संख्या से मेल खाता है। हालांकि [] प्रकार:

scala> Nat(3)
res10: shapeless.Succ[shapeless.Succ[shapeless.Succ[shapeless._0]]] = Succ()

तो 1000000 की संख्या का प्रतिनिधित्व करने के लिए, आपके पास एक ऐसा प्रकार होगा जो 1000000 के स्तर पर गहरा होता है, जो निश्चित रूप से स्कैला संकलक को उड़ा देगा। वर्तमान सीमा प्रयोग से लगभग 400 प्रतीत होती है, लेकिन उचित संकलन समय के लिए, संभवतः 50 से नीचे रहना सबसे अच्छा होगा।

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

scala> type OneMillion = Witness.`1000000`.T
defined type alias OneMillion

scala> type AlsoOneMillion = Witness.`1000000`.T
defined type alias AlsoOneMillion

scala> type OneMillionAndOne = Witness.`1000001`.T
defined type alias OneMillionAndOne

scala> implicitly[OneMillion =:= AlsoOneMillion]
res0: =:=[OneMillion,AlsoOneMillion] = <function1>

scala> implicitly[OneMillion =:= OneMillionAndOne]
<console>:16: error: Cannot prove that OneMillion =:= OneMillionAndOne.
       implicitly[OneMillion =:= OneMillionAndOne]
                 ^

यह Array [बाइट] पर बिट संचालन करते समय उसी सरणी आकार को लागू करने के लिए उपयोग किया जा सकता है।

Comments

बस इस उत्तर को देखा, और +1, यह एक अच्छा उदाहरण है। हालांकि यह ध्यान देने योग्य है कि आप टाइप कक्षाएं प्रदान कर सकते हैं जैसे ops.nat.Sumकि Shapeless's जो इस बात का गवाह होगा कि दो प्रकार के स्तर के पूर्णांकों का एक विशेष योग होता है, आदि (उन्हें बस एक मैक्रो द्वारा प्रदान करना होगा)।

— ट्रैविस ब्राउन

यहाँ एक Concatप्रकार वर्ग का एक उदाहरण है जो एक मैक्रो के माध्यम से दो प्रकार के स्तर को समतल करने की अनुमति देता है। टाइप-स्तरीय पूर्णांकों के योग के लिए एक वर्ग संभवतः बहुत समान दिखाई देगा।

— फ्रैंक एस। थॉमस

Answer 2

Natचर्च एन्कोडिंग का उपयोग करके शापलेस के प्रकार में प्राकृतिक संख्याओं को एनकोड करता है। एक वैकल्पिक विधि बिट्स के एक प्रकार के स्तर के रूप में भीलों का प्रतिनिधित्व करने के लिए है।

घने की जाँच करें जो एक निराकार शैली में इस समाधान को लागू करता है।

मैंने थोड़ी देर में इस पर काम नहीं किया है, और इसके Lazyलिए यहाँ और वहाँ 'आकारहीन' के छिड़काव की जरूरत है , जब खोपड़ी छोड़ देती है, लेकिन यह अवधारणा ठोस है :)