निर्भर प्रकार के उदाहरण?

Question

मान लें कि आपके पास 3 ऑब्जेक्ट्स हैं, एक वैश्विक MemoryStore, जिसमें MemorySlabCacheऑब्जेक्ट्स की एक सरणी है , और प्रत्येक MemorySlabCacheमें MemorySlabऑब्जेक्ट्स की एक सरणी है । इस तरह की तरह:

class MemoryStore {
  caches: Array<MemorySlabCache> = []
}

class MemorySlabCache {
  size: Integer
  slabs: Array<MemorySlab> = []
}

class MemorySlab {
  
}

लेकिन बात यह है, यह सब कुछ पर कब्जा नहीं करता है। यह इस तथ्य को पकड़ने की भी जरूरत है कि प्रत्येक MemorySlabCacheका एक आकार है, जिसका उपयोग यह बताने के लिए किया जाता है कि इसमें किस आकार की MemorySlabवस्तुएं हैं। तो यह इस तरह से अधिक है:

class MemoryStore {
  caches: Array<MemorySlabCache> = []
}

class MemorySlabCache {
  size: Integer
  slabs: Array<MemorySlab<size>> = []
}

class MemorySlab<size: Integer> {
  
}

फिर हम अपने कैश बनाते हैं:

let 4bytes = new MemorySlabCache(size: 4)
let 8bytes = new MemorySlabCache(size: 8)
...
let 32bytes = new MemorySlabCache(size: 32)
...
store.caches.push(4bytes, 8bytes, ..., 32bytes, ...)

क्या यह " निर्भर प्रकार ", "एक प्रकार जिसकी परिभाषा एक मूल्य पर निर्भर करती है " के रूप में गिना जाता है ? चूंकि के प्रकार Array<MemorySlab<size>>को निर्दिष्ट मान पर निर्भर है sizeपर क्षेत्र MemorySlabCache। यदि नहीं, तो यह क्या है? यह निर्भर प्रकारों के उदाहरण में क्या होगा?

Answer 1

तो, जवाब यकीनन "हाँ" है, यह निर्भर प्रकारों का एक उदाहरण है। हालाँकि, बहुत सारे सरल उदाहरणों के साथ समस्या यह है कि लोग इसके लिए बनाते हैं कि वे निर्भर टाइपिंग के गैर-तुच्छ पहलुओं को प्रदर्शित नहीं करते हैं।

इस संबंध में तर्क-वितर्क आपका बेहतर है, क्योंकि प्रश्न का प्रकार मनमाने मूल्य पर निर्भर करता है MemorySlabCache। हालाँकि, आप कभी भी MemorySlabCacheस्टैटिकली ज्ञात मूल्य के बिना उपयोग नहीं करते हैं । तो एक और दिलचस्प उदाहरण होगा:

let cacheSize = readInteger(stdin)
store.caches.push(new MemorySlabCache(cacheSize))

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

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