ट्रेसिंग बाधाओं के लिए तकनीक

Question

यहाँ परिदृश्य है: मैंने कुछ कोड को एक प्रकार के हस्ताक्षर के साथ लिखा है और जीएचसी की शिकायत कुछ xऔर के लिए x ~ y नहीं घटा सकती है y। आप आमतौर पर जीएचसी को एक हड्डी फेंक सकते हैं और बस समारोह में बाधा के लिए आइसोमोर्फिज्म जोड़ सकते हैं, लेकिन यह कई कारणों से एक बुरा विचार है:

1. यह कोड को समझने पर जोर नहीं देता है।
2. आप 5 बाधाओं के साथ समाप्त हो सकते हैं जहां किसी ने पर्याप्त किया होगा (उदाहरण के लिए, यदि 5 एक और विशिष्ट बाधा द्वारा निहित हैं)
3. यदि आपने कुछ गलत किया है या यदि जीएचसी अनहेल्दी हो रहा है, तो आप संगीन बाधाओं के साथ समाप्त हो सकते हैं

मैंने केस से जूझते हुए कई घंटे बिताए। मैं साथ खेल रहा हूं syntactic-2.0, और मैं एक डोमेन-स्वतंत्र संस्करण को परिभाषित करने की कोशिश कर रहा था, जिसमें परिभाषित संस्करण के shareसमान है NanoFeldspar.hs।

मेरे पास यह था:

{-# LANGUAGE GADTs, FlexibleContexts, TypeOperators #-}
import Data.Syntactic

-- Based on NanoFeldspar.hs
data Let a where
    Let :: Let (a :-> (a -> b) :-> Full b)

share :: (Let :<: sup,
          Domain a ~ sup,
          Domain b ~ sup,
          SyntacticN (a -> (a -> b) -> b) fi) 
      => a -> (a -> b) -> a
share = sugarSym Let

और जीएचसी could not deduce (Internal a) ~ (Internal b), जो निश्चित रूप से वह नहीं है जिसके लिए मैं जा रहा था। इसलिए या तो मैंने कुछ कोड लिखे थे, जिनका इरादा नहीं था (जो कि बाधा की आवश्यकता थी), या जीएचसी चाहता था कि कुछ अन्य बाधाओं के कारण जो मैंने लिखा था।

यह पता चला है कि मुझे (Syntactic a, Syntactic b, Syntactic (a->b))बाधा सूची में जोड़ने की जरूरत है , जिनमें से कोई भी इसका मतलब नहीं है (Internal a) ~ (Internal b)। मैंने मूल रूप से सही बाधाओं पर ठोकर खाई; मेरे पास अभी भी उन्हें खोजने का एक व्यवस्थित तरीका नहीं है।

मेरे प्रश्न हैं:

1. जीएचसी ने उस बाधा का प्रस्ताव क्यों दिया? कहीं भी सिंटैक्टिक में अड़चन नहीं है Internal a ~ Internal b, तो जीएचसी ने इसे कहां से खींचा?
2. सामान्य तौर पर, क्या तकनीकों का उपयोग एक बाधा की उत्पत्ति का पता लगाने के लिए किया जा सकता है जो जीएचसी का मानना ​​है कि इसकी आवश्यकता है? बाधाओं के लिए यहां तक कि मैं कर सकते हैं अपने आप को पता चलता है, मेरे दृष्टिकोण अनिवार्य रूप से शारीरिक रूप से पुनरावर्ती बाधाओं नीचे लिख कर हमलावर पथ के लिए मजबूर जानवर है। यह दृष्टिकोण मूल रूप से बाधाओं के एक अनंत खरगोश छेद के नीचे जा रहा है और सबसे कम कुशल विधि के बारे में है जिसकी मैं कल्पना कर सकता हूं।

Comments

एक प्रकार के स्तर डिबगर पर कुछ चर्चाएं हुई हैं, लेकिन आम सहमति से लगता है कि टाइपसीचर का आंतरिक तर्क मदद करने वाला नहीं है: / अभी के रूप में हास्केल की बाधा सॉल्वर एक भद्दा अपारदर्शी भाषा है :)

— डैनियल ग्रैज़र

@jozefg क्या आपके पास उस चर्चा के लिए लिंक है?

— क्रोकेआ

अक्सर यह केवल प्रकार के हस्ताक्षर को पूरी तरह से हटाने में मदद करता है और आपको बता देता है कि हस्ताक्षर क्या होना चाहिए।

— टोबियास ब्रांड

किसी तरह aऔर bबाध्य हैं - अपने संदर्भ के बाहर के प्रकार के हस्ताक्षर को देखें - a -> (a -> b) -> aनहीं a -> (a -> b) -> b। शायद यही है? बाधा सॉल्वरों के साथ, वे कहीं भी सकर्मक समानता को प्रभावित कर सकते हैं , लेकिन त्रुटियां आमतौर पर एक स्थान "करीब" दिखाती हैं जहां कसना प्रेरित किया गया था। यह अच्छा होगा हालांकि @jozefg - शायद टैग या कुछ के साथ बाधाओं की घोषणा करते हुए, यह दिखाने के लिए कि वे कहाँ से आए हैं? : s

— अथान क्लार्क

Answer 1

सबसे पहले, आपके फ़ंक्शन में गलत प्रकार है; मुझे पूरा यकीन है कि यह (संदर्भ के बिना) होना चाहिए a -> (a -> b) -> b। जीएचसी 7.10 कुछ हद तक इस ओर इशारा करने में सहायक है, क्योंकि आपके मूल कोड के साथ, यह एक लापता बाधा के बारे में शिकायत करता है Internal (a -> b) ~ (Internal a -> Internal a)। shareजीएचसी 7.10 को ठीक करने के बाद , हमारा मार्गदर्शन करने में सहायक होता है:

1. Could not deduce (Internal (a -> b) ~ (Internal a -> Internal b))

2. उपरोक्त जोड़ने के बाद, हम प्राप्त करते हैं Could not deduce (sup ~ Domain (a -> b))

3. उसे जोड़ने के बाद, हम प्राप्त करते हैं Could not deduce (Syntactic a), Could not deduce (Syntactic b)औरCould not deduce (Syntactic (a -> b))

4. इन तीनों को जोड़ने के बाद, यह अंत में टाइपकास्ट करता है; इसलिए हम साथ समाप्त करते हैं

   share :: (Let :<: sup,
             Domain a ~ sup,
             Domain b ~ sup,
             Domain (a -> b) ~ sup,
             Internal (a -> b) ~ (Internal a -> Internal b),
             Syntactic a, Syntactic b, Syntactic (a -> b),
             SyntacticN (a -> (a -> b) -> b) fi)
         => a -> (a -> b) -> b
   share = sugarSym Let

इसलिए मैं कहूंगा कि जीएचसी हमें अग्रणी बनाने में बेकार नहीं है।

जीएचसी से अपनी अड़चन संबंधी आवश्यकताओं को प्राप्त करने के बारे में आपके प्रश्न के लिए, आप विशेष रूप से जीएचसी के डीबगिंग झंडे की कोशिश कर सकते हैं -ddump-tc-trace, और फिर परिणाम देखने के लिए लॉग के माध्यम से पढ़ सकते हैं कि सेट कहां Internal (a -> b) ~ tऔर (Internal a -> Internal a) ~ tकैसे जोड़े जाते हैं Wanted, लेकिन यह काफी लंबा पढ़ा जाएगा ।

Answer 2

क्या आपने जीएचसी 8.8+ में यह कोशिश की?

share :: (Let :<: sup,
          Domain a ~ sup,
          Domain b ~ sup,
          SyntacticN (a -> (a -> b) -> b) fi,
          _) 
      => a -> (a -> b) -> a
share = sugarSym Let

कुंजी बाधाओं के बीच प्रकार छेद का उपयोग करने के लिए है: _ => your difficult type