शुद्ध / निर्भर प्रकार की प्रणाली का एक संक्षिप्त लेकिन पूर्ण विवरण क्या है?

32

यदि कुछ सरल है, तो इसे कुछ शब्दों के साथ पूरी तरह से समझा जाना चाहिए। यह λ-पथरी के लिए किया जा सकता है:

Λ-पथरी एक सघन व्याकरण (मूल रूप से, एक संरचना) है जिसमें एक कमी नियम है (जिसका अर्थ है कि एक खोज / प्रतिस्थापन प्रक्रिया बार-बार एक विशिष्ट पैटर्न की प्रत्येक घटना पर लागू होती है जब तक कि ऐसा कोई पैटर्न मौजूद नहीं है)।

व्याकरण:

Term = (Term Term) | (λ Var . Term) | Var

कटौती नियम:

((λ var body) term) -> SUBS(body,var,term)
    where `SUBS` replaces all occurrences of `var`
    by `term` in `body`, avoiding name capture.

उदाहरण:

(λ a . a)                             -> (λ a a)
((λ a . (λ b . (b a))) (λ x . x))     -> (λ b . (b (λ x x)))
((λ a . (a a)) (λ x . x))             -> (λ x . x)
((λ a . (λ b . ((b a) a))) (λ x . x)) -> (λ b . ((b (λ x . x)) (λ x . x)))
((λ x . (x x)) (λ x . (x x)))         -> never halts

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

क्या शुद्ध / निर्भर प्रकार की प्रणालियों का संक्षिप्त, पूर्ण विवरण देना संभव है, उसी प्रारूप में मैंने ऊपर λ-पथरी प्रस्तुत की है?

functional-programming  type-theory 
— MaiaVictor
स्रोत
4
प्योर टाइप सिस्टम्स के नियम बहुत संक्षिप्त हैं। बस आसान निर्भर प्रकारों को लागू करने के बारे में है ।
2
तो यह आक्रामक के अर्थ में "शत्रुतापूर्ण" नहीं है, लेकिन इस अर्थ में कि आपको लगता है कि मैं खुद के द्वारा उत्तर खोजने में पर्याप्त प्रयास न दिखाने के लिए बहुत कुछ मांग रहा हूं? अगर ऐसा है, तो मैं मानता हूं कि यह सवाल बहुत अधिक हो सकता है इसलिए शायद यह बुरा है। लेकिन इसके पीछे भी बहुत प्रयास है, क्या आपको लगता है कि मुझे अपने प्रयासों में संपादित करना चाहिए?
— MaiaVictor
3
मैं भी अपने सहकर्मियों की ओर से नाराज हूं, जिन्होंने "ए ट्यूटोरियल इम्प्लीमेंटेशन ऑफ अ डिपेंडेंटली टाइप्ड लैंबडा कैलकुलस" का पाठ लिखा था, जिसने "सिंपल इजी" को एक कामकाजी शीर्षक के रूप में बदल दिया। मैंने कोड का कर्नेल लिखा था, जो हास्केल की <100 लाइनों में एक टाइपकास्ट है।
2
तब मैंने निश्चित रूप से खुद को बुरी तरह से व्यक्त किया। मुझे "सिंपल इज़ी" पेपर बहुत पसंद है और कुछ दिनों पहले से हर ब्रेक में इसे पढ़ रहा हूं - यह दुनिया की एकमात्र ऐसी चीज है जिसने मुझे एक आंशिक सनसनी दी है जो मैं इस विषय को समझने लगा हूं (और मुझे लगता है कि मैंने कोशिश की) । लेकिन मुझे लगता है कि यह एक सार्वजनिक उद्देश्य से अधिक ज्ञान के साथ मेरे पास है, और यही कारण है कि मुझे अभी भी इसका हिस्सा बनने में कुछ परेशानी हो रही है। कागज की गुणवत्ता के साथ कुछ नहीं करना है, लेकिन मेरी अपनी सीमाएं हैं।
— MaiaVictor
1
@pigworker और कोड मेरा पसंदीदा हिस्सा है, बिल्कुल इसलिए क्योंकि यह (अंग्रेजी स्पष्टीकरण के संबंध में) बहुत छोटा है, फिर भी पूरा है, पूरे का स्पष्टीकरण, जैसा कि मैंने यहां पूछा है। क्या आपके पास उस कोड की एक प्रति होनी चाहिए जिसे मैं डाउनलोड कर सकता हूं?
— MaiaVictor

जवाबों:

7

अस्वीकरण

यह बहुत ही अनौपचारिक है, जैसा आपने अनुरोध किया था।

व्याकरण

एक भरोसेमंद रूप से टाइप की गई भाषा में हमारे पास टाइप स्तर के साथ-साथ मूल्य स्तर पर एक बाइंडर है:

Term = * | (∀ (Var : Term). Term) | (Term Term) | (λ Var. Term) | Var

अच्छी तरह से टाइप किया हुआ शब्द संलग्न प्रकार के साथ एक शब्द है, हम लिखेंगे t ∈ σया

σ
t

यह बताने के लिए कि शब्द tमें टाइप है σ।

टाइपिंग नियम

सादगी के लिए हमें आवश्यकता है कि λ v. t ∈ ∀ (v : σ). τदोनों में λऔर ∀एक ही चर ( vइस मामले में) को बांधें ।

नियम:

t ∈ σ is well-formed if σ ∈ * and t is in normal form (0)

*            ∈ *                                                 (1)
∀ (v : σ). τ ∈ *             -: σ ∈ *, τ ∈ *                     (2)
λ v. t       ∈ ∀ (v : σ). τ  -: t ∈ τ                            (3)
f x          ∈ SUBS(τ, v, x) -: f ∈ ∀ (v : σ). τ, x ∈ σ          (4)
v            ∈ σ             -: v was introduced by ∀ (v : σ). τ (5)

इस प्रकार, *"सभी प्रकारों का प्रकार" (1), ∀प्रकारों से प्रकार (2), लंबोदर अमूर्त में पाई-प्रकार (3) हैं और यदि vद्वारा प्रस्तुत किया गया है ∀ (v : σ). τ, तो vटाइप σ(5) है।

"सामान्य रूप में" का अर्थ है कि हम कमी नियम का उपयोग करके यथासंभव कम कटौती करते हैं:

"कमी" नियम

(λ v. b ∈ ∀ (v : σ). τ) (t ∈ σ) ~> SUBS(b, v, t) ∈ SUBS(τ, v, t)
    where `SUBS` replaces all occurrences of `v`
    by `t` in `τ` and `b`, avoiding name capture.

या जहां दो आयामी वाक्यविन्यास में

σ
t

साधन t ∈ σ:

(∀ (v : σ). τ) σ    SUBS(τ, v, t)
                 ~>
(λ  v     . b) t    SUBS(b, v, t)

केवल एक शब्द के लिए एक लैम्ब्डा अमूर्त लागू करना संभव है जब शब्द में एक ही प्रकार होता है जैसा कि संबंधित फोर्ल क्वांटिफायर में चर होता है। फिर हम लैम्ब्डा एब्सट्रैक्शन और फोरल क्वांटिफायर दोनों को उसी तरह कम करते हैं जैसे कि पहले शुद्ध लैम्ब्डा कैलकुलस में। मान स्तर भाग को घटाने के बाद, हमें (4) टाइपिंग नियम मिलता है।

एक उदाहरण

यहां फ़ंक्शन एप्लिकेशन ऑपरेटर है:

∀ (A : *) (B : A -> *) (f : ∀ (y : A). B y) (x : A). B x
λ  A       B            f                    x     . f x

( यदि हम उल्लेख नहीं ∀ (x : σ). τकरते हैं σ -> τतो संक्षिप्त करें )τx

fB yकिसी भी yप्रकार के लिए रिटर्न A। हम इस पर लागू होते fहैं x, जो सही प्रकार का है A, और इसके बाद के विकल्प के yलिए , इस प्रकार ~> ।x∀.f x ∈ SUBS(B y, y, x)f x ∈ B x

आइए अब फ़ंक्शन एप्लिकेशन ऑपरेटर को संक्षिप्त करें appऔर इसे स्वयं लागू करें:

∀ (A : *) (B : A -> *). ?
λ  A       B          . app ? ? (app A B)

मुझे ?उन शर्तों के लिए जगह चाहिए जो हमें प्रदान करने की आवश्यकता है। पहले हम स्पष्ट रूप से परिचय और तात्कालिकता Aऔर B:

∀ (f : ∀ (y : A). B y) (x : A). B x
app A B

अब हमारे पास जो कुछ है उसे एकजुट करने की जरूरत है

∀ (f : ∀ (y : A). B y) (x : A). B x

जो जैसा है वैसा है

(∀ (y : A). B y) -> ∀ (x : A). B x

और क्या app ? ?प्राप्त होता है

∀ (x : A'). B' x

इसका परिणाम यह होगा

A' ~ ∀ (y : A). B y
B' ~ λ _. ∀ (x : A). B x -- B' ignores its argument

(यह भी देखें कि भविष्यवाणी क्या है? )

हमारी अभिव्यक्ति (कुछ नाम बदलने के बाद) हो जाती है

∀ (A : *) (B : A -> *). ?
λ  A       B          . app (∀ (x : A). B x) (λ _. ∀ (x : A). B x) (app A B)

किसी भी के लिए A, Bऔर f(जहां f ∈ ∀ (y : A). B y)

∀ (y : A). B y
app A B f

हम तुरंत Aऔर उचित प्रकार के साथ B(किसी fके लिए) प्राप्त कर सकते हैं

∀ (y : ∀ (x : A). B x). ∀ (x : A). B x
app (∀ (x : A). B x) (λ _. ∀ (x : A). B x) f

और प्रकार हस्ताक्षर के बराबर है (∀ (x : A). B x) -> ∀ (x : A). B x।

पूरी अभिव्यक्ति है

∀ (A : *) (B : A -> *). (∀ (x : A). B x) -> ∀ (x : A). B x
λ  A       B          . app (∀ (x : A). B x) (λ _. ∀ (x : A). B x) (app A B)

अर्थात

∀ (A : *) (B : A -> *) (f : ∀ (x : A). B x) (x : A). B x
λ  A       B            f                    x     .
    app (∀ (x : A). B x) (λ _. ∀ (x : A). B x) (app A B) f x

जो मूल्य स्तर पर सभी कटौती के बाद समान appवापस देता है ।

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

प्रकार की जाँच

  • यदि tहै *तो t ∈ *(1)
  • अगर tहै ∀ (x : σ) τ, σ ∈? *, τ ∈? *(के बारे में टिप्पणी देखें ∈?नीचे) तो t ∈ *(2)
  • अगर tहै f x, f ∈ ∀ (v : σ) τकुछ के लिए σऔर τ, x ∈? σतब t ∈ SUBS(τ, v, x)से (4)
  • यदि tएक चर है v, तब तक (5) द्वारा vपेश किया गया था∀ (v : σ). τt ∈ σ

ये सभी इंजेक्शन नियम हैं, लेकिन हम लैम्ब्डा के लिए ऐसा नहीं कर सकते हैं (प्रकार निर्भरता निर्भर प्रकारों के लिए अनिर्दिष्ट है)। इसलिए लंबोदर के लिए हम ( t ∈? σ) के बजाय अनुमान लगाते हैं:

  • तो tहै λ v. bऔर उसकी जांच ∀ (v : σ) τ, b ∈? τतोt ∈ ∀ (v : σ) τ
  • यदि tकुछ और है और σउसके खिलाफ जांच की गई है तो tउपरोक्त फ़ंक्शन का उपयोग करने के प्रकार का पता लगाएं और जांचें कि क्या यह हैσ

प्रकारों की समानता की जाँच के लिए उन्हें सामान्य रूपों में होना आवश्यक है, इसलिए यह तय करने के लिए कि हमारे tपास σपहले σटाइप किया गया प्रकार है या नहीं *। यदि ऐसा है, तो σसामान्य है (मोडुलो गिरार्ड का विरोधाभास) और यह सामान्य हो जाता है (इसलिए σ(0) द्वारा अच्छी तरह से बन जाता है)। SUBSसंरक्षित करने के लिए भावों को भी सामान्य करता है (0)।

इसे द्विदिश प्रकार-जाँच कहा जाता है। इसके साथ हमें प्रत्येक लंबोदर को एक प्रकार के साथ एनोटेट करने की आवश्यकता नहीं है: यदि f xप्रकार में fजाना जाता है, तो xतर्क के प्रकार की तुलना में जाँच की जाती है कि fअनुमान लगाया जा रहा है और समानता के लिए तुलना की जाती है (जो कि कम कुशल भी है)। लेकिन अगर fएक लैम्ब्डा है, यह एक स्पष्ट प्रकार एनोटेशन की आवश्यकता होती है (एनोटेशन व्याकरण में छोड़े गए हैं और हर जगह, आप या तो जोड़ सकते हैं Ann Term Termया λ' (σ : Term) (v : Var)निर्माताओं के लिए)।

इसके अलावा, सरल, आसान पर एक नज़र है ! ब्लॉग पोस्ट।

— user3237465
स्रोत
1
"सिंपल, इजीयर" को सुरक्षित करना।
फोर्ल पर पहला कमी नियम अजीब लगता है। लैम्ब्डा के विपरीत, फोर्ल्स को अच्छी तरह से टाइप किया हुआ नहीं होना चाहिए (दाएं?)।
@chi, मुझे समझ नहीं आ रहा है कि आप क्या कह रहे हैं। शायद मेरी धारणा खराब है: कमी नियम कहता है (λ v. b ∈ ∀ (v : σ). τ) (t ∈ σ)~> SUBS(b, v, t) ∈ SUBS(τ, v, t)।
— user3237465
1
मुझे नोटेशन भ्रामक लगता है। ऐसा लगता है जैसे आपके दो नियम थे: एक निरर्थक के (∀ (v : σ). τ) t ~> ...लिए दूसरा दूसरे के लिए (λ v. b) t ~> ...। मैं पहले हटाऊंगा, और नीचे टिप्पणी में बदलूंगा।
1
नियम (1) में आधार के रूप में इसका निष्कर्ष है। आप अपने सिस्टम की सादगी की तुलना द्विदिश संस्करण से कर सकते हैं केवल एक बार आपके पास एक सिस्टम है जो काम करता है। आप कह सकते हैं कि आप सब कुछ सामान्यीकृत रख सकते हैं, लेकिन आपके नियम नहीं हैं।
24

चलिए हम चलते हैं। मैं गिरार्ड के विरोधाभास के बारे में परेशान नहीं करूंगा, क्योंकि यह केंद्रीय विचारों से विचलित होता है। मुझे निर्णय और व्युत्पत्तियों और इस तरह के बारे में कुछ प्रस्तुति मशीनरी पेश करने की आवश्यकता होगी।

व्याकरण

शब्द :: = (एलिम) | * (वार: टर्म) → टर्म | λVar↦Term

एलिम :: = टर्म: टर्म | वार | एलिम शब्द

व्याकरण के दो पारस्परिक रूप से परिभाषित रूप हैं, "शब्द" जो कि सामान्य धारणा है (प्रकार चीजें हैं, मूल्य चीजें हैं), सहित * (प्रकार के प्रकार), आश्रित फ़ंक्शन प्रकार, और लैम्ब्डा-सार, लेकिन एम्बेड करना " विलोपन "(अर्थात" कंस्ट्रक्शन "के बजाय" usages "), जो नेस्टेड एप्लिकेशन होते हैं, जहां अंततः फ़ंक्शन की स्थिति में बात या तो एक चर या एक शब्द है जो इसके प्रकार के साथ एनोटेट किया गया है।

न्यूनीकरण नियम

(λy Tt: (x: S) → T) s s t [s: S / y]: T [s: S / x]

(t: T) ↝ t

प्रतिस्थापन ऑपरेशन t [e / x] वैरिएबल x की प्रत्येक घटना को नाम ए से बचने के साथ उन्मूलन ई के साथ बदल देता है। एक आवेदन है कि कम कर सकते हैं के रूप में करने के लिए, एक लैम्ब्डा अवधि अपने प्रकार द्वारा एनोटेट किया जाना चाहिए एक बनाने के लिए उन्मूलन । प्रकार एनोटेशन लैम्बडा-एब्स्ट्रैक्शन को एक प्रकार की "प्रतिक्रियाशीलता" देता है, जिससे एप्लिकेशन आगे बढ़ता है। एक बार जब हम उस बिंदु पर पहुँच जाते हैं जहाँ कोई अधिक अनुप्रयोग नहीं हो रहा है और सक्रिय t: T शब्द वाक्य रचना में वापस सन्निहित हो रहा है, तो हम टाइप एनोटेशन को छोड़ सकते हैं।

आइए संरचनात्मक बंद करके extend कटौती के संबंध का विस्तार करें: नियम कहीं भी नियम और शर्तों के अंदर लागू होते हैं जो आपको बाएं हाथ की ओर मेल खाते हुए कुछ मिल सकते हैं। रिफ्लेक्टिव-ट्रांसेटिव (0-or-more-step) को बंद करने के लिए Write * लिखें। परिणामी कमी प्रणाली इस अर्थ में संगम है:

यदि s then * p और s q * q है, तो कुछ r मौजूद है जैसे p ↝ * r और q। * R।

संदर्भों

प्रसंग :: = | प्रसंग, वार: पद

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

निर्णय

निर्णय :: = संदर्भ has शब्द में शब्द है | प्रसंग ⊢ एलिम शब्द है

यह निर्णय का व्याकरण है, लेकिन उन्हें कैसे पढ़ा जाए? एक शुरुआत के लिए, trad पारंपरिक "टर्नस्टाइल" प्रतीक है, निष्कर्षों को मान्यताओं को अलग करते हुए: आप इसे अनौपचारिक रूप से "कहते हैं" के रूप में पढ़ सकते हैं।

जी G टी ने टी

इसका अर्थ है कि दिया गया संदर्भ G, टाइप T मानता है;

जी S ई एस है

इसका अर्थ है कि दिए गए संदर्भ G, उन्मूलन e को टाइप S दिया गया है।

निर्णयों में दिलचस्प संरचना है: शून्य या अधिक इनपुट , एक या अधिक विषय , शून्य या अधिक आउटपुट ।

INPUTS                   SUBJECT        OUTPUTS
Context |- Term   has    Term
Context |-               Elim      is   Term

है यही कारण है कि, हम शब्दों के प्रकार का प्रस्ताव करना चाहिए पहले से और बस की जांच के लिए उन्हें है, लेकिन हम संश्लेषण eliminations के प्रकार।

टाइपिंग नियम

मैं इन्हें एक जोरदार प्रोलॉग शैली में प्रस्तुत करता हूं, जे -: पी 1 लिख रहा हूं; ...; Pn यह दर्शाता है कि निर्णय J धारण करता है यदि Pn के माध्यम से परिसर P1 भी धारण करता है। एक आधार एक और निर्णय होगा, या कमी के बारे में दावा होगा।

शर्तें

जी G टी में टी है: - टी ⊢ आर; जी G आर ने टी

जी G * है *

जी G * में (x: S) → T -: G has * है S; जी, जेड: एस! - * में टी [जेड / एक्स] है

G G (x: S) → T में λy --t -: G, z: S [T [z / x] t [z / y] है

जी G टी है (ई) -: जी T ई टी है

एलिमिनेशन

जी G ई आर है -: जी ⊢ ई एस है; एस ↝ आर

जी, एक्स: एस, जी ': एक्स एस है

जी x एफएस टी [एस: एस / एक्स] -: जी (एफ है (एक्स: एस) → टी; जी s एस ने किया है

और बस!

केवल दो नियम वाक्य-निर्देशित नहीं हैं : वह नियम जो "किसी शब्द को जांचने के लिए उपयोग करने से पहले आप एक प्रकार को कम कर सकते हैं" और नियम कहता है कि "आप इसे समाप्त करने के बाद एक प्रकार को कम कर सकते हैं"। एक व्यवहार्य रणनीति प्रकारों को कम करने के लिए है जब तक कि आप सबसे ऊपर के निर्माता को उजागर नहीं करते हैं।

यह प्रणाली दृढ़ता से सामान्य नहीं हो रही है (गिरार्ड के विरोधाभास के कारण, जो आत्म-संदर्भ का एक झूठा-शैली विरोधाभास है), लेकिन इसे "ब्रह्मांड स्तरों" में विभाजित करके दृढ़ता से सामान्य बनाया जा सकता है जहां कोई भी मूल्य जो निचले स्तरों के प्रकारों को खुद में शामिल करता है। उच्च स्तर पर प्रकार, स्व-संदर्भ को रोकते हैं।

हालाँकि, यह प्रणाली, इस अर्थ में, प्रकार के संरक्षण की संपत्ति है।

यदि G and T में t और G ⊢ * D और T and * R और t, r है, तो D। R में r है।

यदि G and e S है और G ⊢ * D और e then f है, तो R मौजूद है जैसे S D * R और D and f, R है।

संदर्भों की गणना उन शब्दों की अनुमति देकर की जा सकती है, जिनकी वे गणना करते हैं। यही है, यदि कोई निर्णय अभी मान्य है, तो आप इसके इनपुट की गणना उतने ही कर सकते हैं जितनी आप और इसके विषय एक कदम के रूप में करते हैं, और फिर इसके आउटपुट को किसी भी तरह से गणना करना संभव होगा ताकि परिणामी निर्णय मान्य हो सके। प्रमाण - टाइपिंग व्युत्पत्तियों पर एक सरल प्रेरण है, जिसे -> * का संगम माना जाता है।

बेशक, मैंने यहां केवल कार्यात्मक कोर प्रस्तुत किया है, लेकिन एक्सटेंशन काफी मॉड्यूलर हो सकते हैं। यहाँ जोड़े हैं।

शब्द :: = ... | (x: S) * T | रों, टी

एलिम :: = ... | ई.हेड | e.tail

(एस, टी: (एक्स: एस) * टी)। हेड S एस: एस

(s, t: (x: S) * T) .टेल T t: T [s: S / x]

जी G * में है (एक्स: एस) * टी -: जी has * में एस है; जी, जेड: एस ⊢ * में टी [जेड / एक्स] है

जी G (एक्स: एस) * टी में एस, टी -: जी s एस है; जी G टी [एस: एस / एक्स] टी है

जी G ई.हेड एस -: जी (ई है (एक्स: एस) * टी

G / e.tail T है [e.head / x] -: G (e है (x: S) * T

— pigworker
स्रोत
1
G, x:S, G' ⊢ x is S -: G' ⊬ x?
— user3237465
1
@ user3237465 नहींं। धन्यवाद! फिक्स्ड। (खेद है कि के कहीं और हो रहा) मैं याद किया है कि एक जब मैं एचटीएमएल turnstiles (इस प्रकार उन्हें मेरे फोन पर अदृश्य बनाने के साथ ascii कला turnstiles की जगह किया गया था।)
1
ओह, मुझे लगा कि आप केवल टाइपो को इंगित कर रहे हैं। नियम कहता है कि, संदर्भ में प्रत्येक चर के लिए, हम उस प्रकार को संश्लेषित करते हैं जो संदर्भ इसे असाइन करता है। संदर्भों को प्रस्तुत करते समय, मैंने कहा "हम अपरिवर्तनीय बनाए रखते हैं कि संदर्भ में टाइप किए गए चर अलग-अलग हैं।" इसलिए शैडोइंग को रोक दिया गया है। आप देखेंगे कि जब भी नियम संदर्भ का विस्तार करते हैं, तो वे हमेशा एक नए "z" का चयन करते हैं, जो कि हम जो भी बांध रहे हैं, उसे तुरंत रोक देते हैं। छायांकन एक अनात्म है। यदि आपके पास संदर्भ x: *, x: x है, तो अधिक स्थानीय x का प्रकार अब ठीक नहीं है क्योंकि यह x के दायरे से बाहर है।
1
मैं सिर्फ आपको और अन्य उत्तरदाताओं को यह जानना चाहता था कि मैं काम से हर ब्रेक पर इस धागे पर वापस आ रहा हूं। मैं वास्तव में यह सीखना चाहता हूं, और पहली बार मैं इस तरह गिर गया जैसे मैं वास्तव में इसे प्राप्त करता हूं। अगला कदम कुछ कार्यक्रमों को लागू करना और लिखना होगा। मुझे ऐसे युग में रहने में खुशी हो रही है जहां दुनिया भर में मेरे जैसे किसी व्यक्ति के लिए ऐसे अद्भुत विषयों की जानकारी उपलब्ध है, और यह सब आप जैसे प्रतिभाशाली लोगों के लिए धन्यवाद है जो उस ज्ञान को फैलाने के लिए अपने जीवन का कुछ समय समर्पित करते हैं, इंटरनेट पर मुफ्त। मेरे प्रश्न को बुरी तरह से समझने के लिए फिर से क्षमा करें, और धन्यवाद!
— MaiaVictor
1
@ कोडी हां, कोई विस्तार नहीं है। यह देखने के लिए कि यह आवश्यक क्यों नहीं है, ध्यान दें कि दो गणना नियम आपको रणनीति की तैनाती करने की अनुमति देते हैं जहां आप शर्तों की जांच करने से पहले पूरी तरह से सामान्य करते हैं, और आप उन्हें खत्म करने के बाद संश्लेषित करने के तुरंत बाद प्रकारों को भी सामान्य करते हैं। इसलिए नियम में जहां प्रकारों का मिलान होना चाहिए, वे पहले से ही सामान्यीकृत हैं, इसलिए नाक पर बराबर अगर "मूल" की जाँच की और संश्लेषित प्रकार परिवर्तनीय थे। इस बीच, केवल इस तथ्य के कारण उस स्थान पर समानता जांच को प्रतिबंधित करना: यदि टी एक कैनोनिकल प्रकार के लिए परिवर्तनीय है, तो यह एक कैनोनिकल प्रकार के लिए कम हो जाती है।
— सूअर का बच्चा
8

करी-हावर्ड पत्राचार कहता है कि तर्क में टाइप सिस्टम और प्रूफ सिस्टम के बीच एक व्यवस्थित पत्राचार है। इसका एक प्रोग्रामर-केंद्रित दृष्टिकोण लेते हुए, आप इसे इस तरह से पढ़ सकते हैं:

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

इस कोण से देखा गया:

  • आपके द्वारा संक्षेपित लाम्बडा कैलकुलस में एक महत्वपूर्ण प्रकार की प्रणाली नहीं है, इसलिए इस पर बनाया गया एक प्रूफ सिस्टम निराधार होगा।
  • बस टाइप की गई लैम्ब्डा कैलकुलस एक प्रोग्रामिंग लैंग्वेज है, जिसमें सभी प्रकार के आवश्यक साक्ष्य लॉजिक ("अगर / फिर", "और", "या", "नहीं") में साउंड प्रूफ बनाने के लिए आवश्यक है। लेकिन इसके प्रकार प्रमाणों की जांच करने के लिए पर्याप्त नहीं हैं, जिसमें क्वांटिफायर शामिल हैं ("सभी एक्स, ..." के लिए; "एक एक्स मौजूद है जैसे ...")।
  • भरोसेमंद रूप से टाइप किए गए लैम्ब्डा कैलकुलस में प्रकार और नियम होते हैं जो भावुक तर्क और प्रथम-ऑर्डर क्वांटिफायर (मूल्यों पर मात्रा का ठहराव) का समर्थन करते हैं।

प्राकृतिक कटौती पर विकिपीडिया प्रविष्टि से आरेख का उपयोग करते हुए, पहले-क्रम तर्क के लिए प्राकृतिक कटौती के नियम हैं । ये मूल रूप से न्यूनतम भरोसेमंद टाइप किए गए लैम्ब्डा कैलकुलस के नियम हैं।

प्रथम-क्रम प्राकृतिक कटौती

ध्यान दें कि नियमों में लंबित शर्तें हैं। इन्हें उन कार्यक्रमों के रूप में पढ़ा जा सकता है जो उनके प्रकारों (या अधिक संक्षेप में, हम केवल उन कार्यक्रमों को प्रमाण कहते हैं ) द्वारा दर्शाए गए वाक्यों के प्रमाणों का निर्माण करते हैं । इसी तरह के कमी नियम जो आप देते हैं उन्हें इन लंबोदर शर्तों पर लागू किया जा सकता है।

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

दूसरा, क्योंकि क्वांटिफायर को संभालने के लिए जिस प्रकार की सिस्टम मशीनरी की जरूरत होती है, वह प्रोग्रामिंग संदर्भ में अन्य उपयोग हो सकती है। विशेष रूप से, भरोसेमंद रूप से टाइप की गई भाषाएं सार्वभौमिक क्वांटिफायर ("सभी x, ...") के लिए एक अवधारणा का उपयोग करके संभालती हैं, जिसे आश्रित फ़ंक्शन प्रकार -ए फ़ंक्शन कहा जाता है, जहां परिणाम का स्थिर प्रकार तर्क के रनटाइम मान पर निर्भर कर सकता है।

इसका एक बहुत ही पैदल आवेदन देने के लिए, मैं हर समय कोड लिखता हूं जिसमें एवरो फ़ाइलों को पढ़ना पड़ता है जिसमें समान संरचना के साथ रिकॉर्ड होते हैं - सभी फ़ील्ड नामों और प्रकारों के समान सेट को साझा करते हैं। यह मुझे या तो करने की आवश्यकता है:

  1. कार्यक्रम में रिकॉर्ड प्रकार के रूप में संरचना की हार्डकोड।
    • लाभ: कोड सरल है और संकलक मेरे कोड में त्रुटियां पकड़ सकता है
    • नुकसान: कार्यक्रम रिकॉर्ड प्रकार से सहमत फ़ाइलों को पढ़ने के लिए हार्डकोड किया गया है।
  2. रनटाइम पर डेटा का स्कीमा पढ़ें, इसे डेटा संरचना के रूप में उदारतापूर्वक प्रस्तुत करें और रिकॉर्ड को संसाधित करने के लिए इसका उपयोग करें
    • लाभ: मेरा प्रोग्राम केवल एक फ़ाइल प्रकार के लिए हार्डकोड नहीं है
    • नुकसान: कंपाइलर कई त्रुटियों को नहीं पकड़ सकता।

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

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

— sacundim
स्रोत
1
आपके द्वारा बताए गए फैशन के समय में बिल्डिंग प्रकार वास्तव में बहुत अच्छा है, जिसके बारे में मैंने सोचा नहीं है। बल्कि मीठा, वास्तव में! इस व्यावहारिक उत्तर के लिए धन्यवाद।
— MaiaVictor
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.