स्ट्रीम-विपक्ष # :: स्कैला में अनुवाद कैसे किया जाता है?

Question

मैं वर्तमान में "प्रोग्रामिंग इन स्कैला" पुस्तक के माध्यम से काम करके स्कैला सीख रहा हूं। अब तक, वहाँ सब कुछ है कि (एक जावा प्रोग्रामर के नजरिए से) अजीब लग रहा है के लिए अच्छा स्पष्टीकरण किया गया है, लेकिन यह एक एक स्ट्रीम का उपयोग कर फाइबोनैचि अनुक्रम उत्पन्न करने के लिए उदाहरण छोड़ देता है मुझे एक तरह से हैरान:

def fibFrom(a: Int, b: Int): Stream[Int] = 
    a #:: fibFrom(b, a + b) 

निर्माण कैसे है स्ट्रीम की? बेशक #:: ऑपरेटर किसी भी तरह जिम्मेदार है। मैं समझता हूं कि चूंकि यह : में समाप्त होता है, यह सही-सहयोगी है, लेकिन यह स्ट्रीम के निर्माण की व्याख्या नहीं करता है। मुझे लगता है कि यह किसी भी तरह से एक कन्स्ट्रक्टर में स्पष्ट रूप से अनुवादित है लेकिन मुझे नहीं पता कि क्यों और कैसे बिल्कुल।

मैं पहले से ही Predef.scala और LowPriorityImplicits.scala में जवाब के लिए देखा है, लेकिन कोई किस्मत अब तक।

क्या कोई मुझे प्रबुद्ध कर सकता है?

Answer 1

यह सही साहचर्य है, इसलिए यह सही तर्क पर एक तरीके के रूप में काम करता है:

fibFrom(b, a + b).#::(a) 

कम से कम है कि यह वाक्य रचना करने की कोशिश करता क्या है। Stream[Int] में ऐसी कोई विधि नहीं है। सौभाग्य से, object Stream कुछ वर्ग ConsWrapper पर निहित है जिसमें इस विधि (code) है।

तो, आप अंतर्निहित संकल्प के बाद क्या मिलता है यह है:

immutable.this.Stream.consWrapper(fibFrom(b, a + b)).#::(a) 

Answer 2

किसी धारा के एक सूची के समान है। यह केवल उसके सिर और बाकी धारा जानता है: स्ट्रीम (सिर: टी, पूंछ: स्ट्रीम [टी])। अंतर यह है कि एक स्ट्रीम का आलसी मूल्यांकन किया जाता है। विधि के नाम के अंत में ':' कहता है कि विधि सही सहयोगी है। तो अभिव्यक्ति एक # :: fibFrom (बी, ए + बी) का अनुवाद (कंपाइलर द्वारा) fibFrom (बी, ए + बी) में किया जाता है। #: :(ए)।