ग़ुशी रेगिस्तानों की सूचियों और परिवारों को टाइप क्यों करती है? क्या इसे चुनिंदा रूप से अक्षम किया जा सकता है?

Question

मैं अपने पुस्तकालयों के लिए संभव के रूप में प्रदर्शित करने के लिए प्रकार ghci प्रदर्शित करने की कोशिश कर रहा हूँ, लेकिन अधिक उन्नत सुविधाओं का उपयोग करते समय मैं बहुत कठिनाइयों में चल रहा हूँ।

मान लें कि मेरे पास फ़ाइल में यह कोड है:

{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeOperators #-}

import GHC.TypeLits

data Container (xs::[*]) = Container

मैं इसे ghci में लोड करता हूं, फिर मैं निम्नलिखित कमांड टाइप करता हूं:

ghci> :t undefined :: Container '[String,String,String,String,String]

दुर्भाग्य से, ghci मुझे बल्कि बदसूरत दिखने देता है:

:: Container
       ((':)
          *
          String
          ((':)
             * String ((':) * String ((':) * String ((':) * String ('[] *))))))

ghci ने टाइप लेवल स्ट्रिंग्स के लिए चीनी को हटा दिया है। वहाँ ghci को ऐसा करने और मुझे सिर्फ सुंदर संस्करण देने से रोकने का कोई तरीका है?

---

संबंधित नोट पर, मैं कहता हूं कि मैं एक प्रकार का स्तर Replicateफ़ंक्शन बनाता हूं

data Nat1 = Zero | Succ Nat1

type family Replicate (n::Nat1) x :: [*]
type instance Replicate Zero x = '[]
type instance Replicate (Succ n) x = x ': (Replicate n x)

type LotsOfStrings = Replicate (Succ (Succ (Succ (Succ (Succ Zero))))) String

अब, जब मैं एक प्रकार का उपयोग करने के लिए ghci पूछना LotsOfStrings:

ghci> :t undefined :: Container LotsOfStrings

ghci अच्छा है और मुझे सुंदर परिणाम देता है:

undefined :: Container LotsOfStrings

लेकिन अगर मैं Replicateडी संस्करण के लिए पूछना ,

ghci> :t undefined :: Container (Replicate (Succ (Succ (Succ (Succ (Succ Zero))))) String)

ghci प्रकार परिवार के लिए विकल्प है जब उसने ऐसा नहीं किया है जो टाइप के पर्यायवाची के लिए है:

:: Container
       ((':)
          *
          [Char]
          ((':)
             * [Char] ((':) * [Char] ((':) * [Char] ((':) * [Char] ('[] *))))))

क्यों ghci प्रकार परिवार के लिए प्रतिस्थापन कर रहा है, लेकिन प्रकार समानार्थक नहीं? क्या नियंत्रण करने का कोई तरीका है जब ghci प्रतिस्थापन करेगा?

Comments

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

— एंड्रयूसी

आपकी समस्या का समाधान आपके प्रश्न में है - यदि आप संक्षिप्त करना चाहते हैं तो एक प्रकार का पर्यायवाची बनाएं।

— एंड्रयूसी

@AndrewC मैंने अभी आपकी टिप्पणी से संबंधित एक और प्रश्न सोचा है: स्ट्रिंग्स के प्रकार कभी-कभी प्रदर्शित क्यों होते हैं [Char]और कभी-कभी प्रदर्शित होते हैं String?

— माइक इज्बिकि

मुझे लगता है कि ghci स्रोत में पाए जाने वाले प्रकार के समानार्थी शब्द को संरक्षित करने की कोशिश करता है। यही है, यदि कोई फ़ंक्शन प्रकार का घोषित किया जाता है String->String, तो उसके परिणाम के प्रकार को प्रदर्शित किया जाएगा String। हालाँकि अगर इसे टुकड़ों से एक प्रकार का निर्माण करना है, जैसे कि उदाहरण के लिए "abc"(जो कि जैसा है 'a':'b':'c':[]) संरक्षित करने का कोई पर्याय नहीं है। यह शुद्ध अटकल है।

— एन। 'सर्वनाम' मी।

@ एसएम: ध्यान दें कि जीएचसी एक प्रकार के चर के नामों को संरक्षित करने का एक समान प्रयास करता है, जब अधिक सामान्य अनुमानित प्रकार कम जेनेरिक, स्पष्ट रूप से नामित चर के साथ एकीकृत होते हैं। मुझे संदेह है कि यदि स्पष्ट प्रकार Stringको प्रकार चर के साथ एकीकृत किया जाता है f aया [a], इसे [Char]समान कारणों के लिए बाद में प्रदर्शित किया जाएगा ।

— सीए मैककैन

Answer 1

वर्कअराउंड जो मुझे पता है वह उपयोग कर रहा है: तरह। उदाहरण के लिए,

ghci>: तरह (कंटेनर '[स्ट्रिंग, स्ट्रिंग, स्ट्रिंग, स्ट्रिंग]]

देता है:

(कंटेनर '[स्ट्रिंग, स्ट्रिंग, स्ट्रिंग, स्ट्रिंग, स्ट्रिंग]) :: *

जबकि

ghci>: दयालु! (कंटेनर '[स्ट्रिंग, स्ट्रिंग, स्ट्रिंग, स्ट्रिंग, स्ट्रिंग])

कुछ इस तरह छपेगा:

पात्र

(( ':)

  *
  [Char]
  ((':)
     * [Char] ((':) * [Char] ((':) * [Char] ((':) * [Char] ('[] *))))))

आधिकारिक तौर पर, बेशक, आप ghci के साथ एक अलग सवाल पूछ रहे हैं kind, लेकिन यह काम करता है। का उपयोग करना undefined ::किसी भी तरह से एक समाधान है, इसलिए मैंने सोचा कि यह पर्याप्त हो सकता है।

Comments

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

— माइक इज़्बिकि

हाँ, काफी उचित है। कैना ने महसूस किया कि हो सकता है। मैं आपको एक बेहतर जवाब देना चाहता हूं

— user2141650

Answer 2

यह आगामी जीएचसी 7.8 में तय किया गया है।

यदि कोई डेटाटाइप PolyKinds का उपयोग करता है तो GHC 7.6 टाइप करता है। तो आप (':) * String ('[] *)बस के बजाय देखते हैं (':) String '[]।

जीएचसी 7.8 में, प्रकार अब डिफ़ॉल्ट रूप से नहीं दिखाए जाते हैं और आपका डेटाटाइप एक सूची के रूप में बहुत मुद्रित होता है, जैसा कि आप उम्मीद करेंगे। -fprint-explicit-kindsजीएचसी 7.6 में स्पष्ट प्रकार देखने के लिए आप नए ध्वज का उपयोग कर सकते हैं । मुझे इसके कारणों का पता नहीं है, संभवतः स्पष्ट रूप से स्पष्ट प्रकार पॉलीकाइंड को समझने के लिए एक सहायता के लिए थे।

Answer 3

import GHC.TypeLits

data Container (xs::[*]) = Container

मैं इसे ghci में लोड करता हूं, फिर मैं निम्नलिखित कमांड टाइप करता हूं:

:t undefined :: Container '[String,String,String,String,String]

Comments

इसलिए...? तुम अब भी परिणाम मैं मायूस लगता है, यानी वापस आ गया String ((':) * String ((':) * String ((':) * ...।

— बाएंवेटाबाउट