रैखिक प्रकार के साथ प्रोग्रामिंग भाषा में डेटा संरचनाएं

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

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

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

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

pl.programming-languages type-theory linear-logic

— Bjørn Kjos-Hanssen
स्रोत

रैखिकता एक अद्वितीय स्टेटफुल प्रतिनिधित्व को कम करने के लिए एक पर्याप्त बाधा नहीं है, और इसलिए आपके प्रश्न का उत्तर इस बात पर निर्भर करता है कि आप राज्य के संदर्भ में रैखिक तर्क की व्याख्या कैसे करते हैं। यह आमतौर पर आप कैसे व्याख्या करना होगा परिलक्षित होता है तरीका। $!A$

यदि आपके संदर्भ के अभिप्रेत शब्दार्थ यह कहते हैं कि सभी संकेत अद्वितीय मूल्य हैं (अर्थात, किसी वस्तु का अधिकतम एक ही संदर्भ है) तो डैग और ग्राफ संरचनाएं व्यक्त नहीं होती हैं, जैसे कि तांत्रिक तर्क के अनुसार कि एक डैग में कई संदर्भ हो सकते हैं एक ही वस्तु। इस मामले में एक होना चाहिए गणना किस प्रकार की एक नई प्रकार महत्व , जब से तुम नक्शे चाहते और । $!A$ $A$ $\delta_A : !A \multimap !A \otimes !A$ $\epsilon_A : !A \multimap A$

हालांकि, लगता है कि आप चाहते हैं प्रतिनिधित्व करने के लिए साझा करने । फिर, ऑब्जेक्ट्स को संदर्भ गिनती के साथ, नक्शे साथ कचरा-एकत्र किया जा सकता है और को ऑपरेशन के रूप में महसूस किया जा सकता है, जो केवल संदर्भ संख्या को गिनता है। इस स्थिति में, आप यह मानने के लिए रैखिकता का उपयोग नहीं कर सकते कि मान साझा करना हमेशा सुरक्षित है, क्योंकि वहाँ साझाकरण है। लेकिन आप यह सुनिश्चित कर सकते हैं कि आपके कार्यक्रम में सभी मेमोरी आवंटन स्पष्ट हैं, और ढेर में कोई चक्र नहीं हैं। $!A$ $\delta_A : !A \multimap !A \otimes !A$ $\epsilon_A : !A \multimap A$

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

\begin{matrix} n e w & : & \forall α . α ⊸ \exists c : ι . c a p (सी) \otimes आर इ च (α, सी) \\ जी इ टी & : & \forall α, सी : ι । सी ए पी (सी) \otimes आर इ च (α, सी) ⊸ α \otimes सी ए पी (सी) \otimes आर इ च (α, सी) \\ रों इ टी & : & \forall α, सी : ι । सी ए पी (सी) \otimes आर इ च (α, सी) \otimes α ⊸ सी ए पी (सी) \otimes आर इ च (α, सी) \\ सी ओ पी y & : & \forall α, सी : ι । आर इ च (α, सी) ⊸ आर इ च (α, सी) \otimes आर इ च (α, सी) \end{matrix}

$\array{ \mathsf{new} & : & \forall \alpha. \;\alpha \multimap \exists c : \iota. \mathsf{cap}(c) \otimes \mathsf{ref}(\alpha, c) \\ \mathsf{get} & : & \forall \alpha, c:\iota. \;\mathsf{cap}(c) \otimes \mathsf{ref}(\alpha, c) \multimap \alpha \otimes \mathsf{cap}(c) \otimes \mathsf{ref}(\alpha, c) \\ \mathsf{set} & : & \forall \alpha, c:\iota. \;\mathsf{cap}(c) \otimes \mathsf{ref}(\alpha, c) \otimes \alpha \multimap \mathsf{cap}(c) \otimes \mathsf{ref}(\alpha, c) \\ \mathsf{copy} & : & \forall \alpha, c:\iota.\; \mathsf{ref}(\alpha,c) \multimap \mathsf{ref}(\alpha,c) \otimes \mathsf{ref}(\alpha,c) }$

ऊपर स्केच किए गए API में, से अधिक , संकलन-समय सूचकांकों के कुछ डोमेन, और प्रकारों में रेंज शामिल हैं। हमारे पास एक type जो द्वारा अनुक्रमित एक क्षमता है , और एक type , जो कि क्षमता द्वारा एक्सेस के संदर्भ का एक प्रकार है । कॉलिंग और एक संदर्भ पर क्षमता की आवश्यकता है , और बुला एक नया संदर्भ और एक नई क्षमता एक साधारण सूचकांक साझा करने बनाता है। हालाँकि, $c$ $\iota$ $\alpha$ $\mathsf{cap}(c)$ $c$ $\mathsf{ref}(\alpha, c)$ $\alpha$ $c$ $\mathsf{get}$ $\mathsf{set}$ $c$ $\mathsf{new}$ $\mathsf{copy}$ -एक संदर्भ में किसी भी क्षमता तक पहुंच की आवश्यकता नहीं होती है, इसलिए कोई भी संदर्भ को तब तक कॉपी कर सकता है जब तक वे उसके अंदर नहीं दिखते।

— नील कृष्णस्वामी
स्रोत

सोचा-समझा जवाब देने के लिए धन्यवाद। हालांकि, मुझे दिलचस्पी है कि क्या अलियासिंग और साझा करने के बीच कोई तकनीकी (तकनीकी) अंतर है? क्या ऐसी कोई प्रणाली है जो धीरे-धीरे रैखिक (अधिकतम एक संदर्भ में) से जा सकती है और अप्रतिबंधित तरीके से साझा करने के लिए सबसे अधिक n संदर्भों द्वारा साझा की जा सकती है?

1. अलियासिंग और शेयरिंग पर्यायवाची शब्द हैं। 2. हां, क्षमता-शैली की व्याख्याएं, बॉयलैंड की आंशिक अनुमति के साथ संवर्धित हैं । पोट्टियर के सिद्धांत के लिए क्षमता गणना पर और हाल ही में कार्यान्वयन के लिए एल्डरिच और बीरहोफ के कार्य पर पोटलियर को भी देखें।

— नील कृष्णस्वामी