__ OCaml में Coq से निकाला

Question

OCaml Coq से निकाला कोड (कुछ मामलों में) भी शामिल है एक प्रकार __ और एक समारोह __ के रूप में परिभाषित इस प्रकार है:

type __ = Obj.t 
let __ = let rec f _ = Obj.repr f in Obj.repr f 

प्रलेखन का कहना है कि अतीत में, इस प्रकार परिभाषित किया गया था unit के रूप में (और इस प्रकार __() के रूप में लिया जा सकता है), लेकिन वहाँ मौजूद (दुर्लभ) ऐसे मामलों में जहां प्रकार __ का एक मान प्रकार __ के एक मूल्य के लिए लागू किया जाता है।

__ OCaml से Obj मॉड्यूल के अनियंत्रित कार्यों का उपयोग करता है, लेकिन ऐसा लगता है कि परिभाषित किया गया है अनिवार्य रूप से एक पूरी तरह से बहुलक कार्य है जो इसके सभी तर्क (जो भी उनकी संख्या) खाता है।

क्या ऐसे मामलों के बारे में कुछ दस्तावेज हैं जहां __ को समाप्त नहीं किया जा सकता है और इस प्रकार के मूल्य सैद्धांतिक (दोनों कोक शब्द जहां उन्मूलन असंभव है) और एक व्यावहारिक से (एक शो दिखाएं) यथार्थवादी मामला जहां यह होता है) दृष्टिकोण का दृष्टिकोण?

Answer 1

संदर्भ README में उद्धृत विलोपन समस्या का एक अच्छा सिंहावलोकन दे। विशेष रूप से, दोनों this रिपोर्ट और विस्तार प्रकार योजनाओं और सीआईसी पदों की तार्किक भागों मिट जाता है, और यही कारण है कि एक __ x = __ होना आवश्यक है में this लेख exaplain। समस्या वास्तव में __ ही लागू किया जाता है नहीं हो सकता है, लेकिन यह है कि यह सब पर कुछ भी करने के लिए लागू किया जा सकता है।

दुर्भाग्य से, यह बिल्कुल स्पष्ट नहीं है कि इस व्यवहार होने पर किसी भी गैर रोग के मामले में महत्वपूर्ण है। वहां दिया गया प्रेरणा किसी भी कोक टर्म निकालने में सक्षम होना है, और दस्तावेज़ किसी भी मामले का उल्लेख नहीं करते हैं जो व्यावहारिक दृष्टिकोण से वास्तव में दिलचस्प है। उदाहरण 3 पर दिए गए इस एक है:

Definition foo (X : Type) (f : nat -> X) (g : X -> nat) := g (f 0). 
Definition bar := foo True (fun _ => I). 

Recursive Extraction bar. निष्पादित निम्न परिणाम देता है:

type __ = Obj.t 
let __ = let rec f _ = Obj.repr f in Obj.repr f 

type nat = 
| O 
| S of nat 

(** val foo : (nat -> 'a1) -> ('a1 -> nat) -> nat **) 

let foo f g = 
    g (f O) 

(** val bar : (__ -> nat) -> nat **) 

let bar = 
    foo (Obj.magic __) 

foo के बाद से Type पर बहुरूपी है, वहाँ अपने शरीर पर f O आवेदन को सरल बनाने का कोई रास्ता नहीं है, क्योंकि इसमें कम्प्यूटेशनल सामग्री हो सकती है। हालांकि, बाद से PropType की एक उप-प्रकार है, foo भी True, जो क्या bar में होता है के लिए लागू किया जा सकता है। जब हम bar को कम करने का प्रयास करते हैं, तो हमारे पास __O पर लागू होगा।

यह विशेष रूप से मामला नहीं बहुत ही दिलचस्प है, क्योंकि यह पूरी तरह से इनलाइन foo संभव हो जाएगा है:

let bar g = 
    g __ 

True के बाद से कुछ भी करने के लिए लागू नहीं किया जा सकता है, अगर g किसी भी कानूनी Coq अवधि से मेल खाती है, इसकी __ तर्क भी किसी भी चीज़ पर लागू नहीं होगा, और इसलिए __ =() (मुझे विश्वास है) सुरक्षित होना सुरक्षित होगा। हालांकि, ऐसे मामले हैं जहां पहले से जानना संभव नहीं है कि एक मिटाई गई अवधि को और लागू किया जा सकता है या नहीं, जो __ के लिए सामान्य परिभाषा बनाता है। उदाहरण के लिए फ़ाइल के अंत के पास Fun उदाहरण here उदाहरण के लिए देखें।