हास्केल: runST

Question

के साथ "अनुमान नहीं किया जा सका" त्रुटि जब मैं इस संकलन करने का प्रयास करें:

module Main where 

import qualified Data.Vector.Unboxed.Mutable as MV 
import Control.Monad.ST 

myRead mv = runST $ MV.read mv 0 

मैं निम्न त्रुटि संदेश मिलता है:

Could not deduce (t ~ U.MVector s a) 
    from the context (U.Unbox a) 
     bound by the inferred type of myRead :: U.Unbox a => t -> a 
     at src/Main.hs:53:1-32 
     `t' is a rigid type variable bound by 
      the inferred type of myRead :: U.Unbox a => t -> a 
      at src/Main.hs:53:1 
    Expected type: U.MVector (PrimState (ST s)) a 
     Actual type: t 
    In the first argument of `MV.read', namely `mv' 
    In the second argument of `($)', namely `MV.read mv 0' 
    In the expression: runST $ MV.read mv 0 

मैं एक परिवर्तनशील वेक्टर से पढ़ने बना सकते हैं रनस्ट के साथ शुद्ध? यदि हां, तो कैसे? मुझे लगता है कि यह myRead के लिए एक प्रकार के हस्ताक्षर में शामिल है, लेकिन मैंने जो भी कोशिश की है, वह सिर्फ अधिक से अधिक समझ में त्रुटि संदेशों का कारण बनता है।

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

Answer 1

अन्य उत्तरों अच्छे हैं, लेकिन मुझे लगता है कि एसटी के बारे में एक मूल बात है जो आप गायब हैं। रनस्ट के लिए प्रत्येक कॉल प्रभावी रूप से एक नया "एसटी ब्रह्मांड" बना रहा है जिसमें कुछ अनिवार्य कोड चलता है। इसलिए यदि आपके पास सरणी बनाने के लिए रनस्ट करने के लिए एक कॉल है और उस सरणी से मूल्य प्राप्त करने के लिए रनस्ट को एक अलग कॉल करने के लिए, चीजें संभवतः काम नहीं कर सकती हैं। दो रनस्ट कॉल अपने अद्वितीय सार्वभौमिक चाहते हैं, जबकि आप उन्हें एक साझा करना चाहते हैं।

कुछ विवरणों में क्या जवाब समझाया गया है यह है कि इन अद्वितीय सार्वभौमिकों को कुछ प्रकार-सिस्टम चालबाजी द्वारा कैसे बनाया जाता है।

Answer 2

संकलक mv को कुछ विशिष्ट प्रकार के रूप में बाईं तरफ तर्क mv देखने के लिए डिफ़ॉल्ट है, लेकिन दाईं ओर पॉलिमॉर्फिक प्रकार की कुछ आवश्यकता है। एक प्रकार का हस्ताक्षर चीजों को ठीक कर सकता है।

{-#LANGUAGE Rank2Types#-} 
module Main where 

import qualified Data.Vector.Unboxed.Mutable as MV 
import Control.Monad.ST 

myRead :: MV.Unbox a => (forall s . MV.MVector s a) -> a 
myRead mv = runST $ MV.read mv 0 

जिनमें आप समारोह के हस्ताक्षर होने कुछ इस तरह होगा, अगर मैं समझता हूँ:

-- myBadRead :: forall s a . MV.Unbox a => MV.MVector s a -> a 
-- myBadRead mv = runST $ MV.read mv 0 

लेकिन यहाँ runST :: (forall s. ST s a) -> a पर काम करने के लिए एक s स्वतंत्र बात नहीं होती, s के बाद से जब आप एलएचएस पर mv लिखते हैं तो तय किया जाता है।

संपादित करें: हालांकि, जोआचिम बी और डैनियल एफ पर बल दिया गया है, हालांकि उपरोक्त परिभाषा सुसंगत है, लेकिन अभ्यास में इसका कोई उपयोग नहीं होगा, क्योंकि आप इसे देने के लिए वेक्टर mv बनाने में सक्षम नहीं होंगे। इसे क्रुद्ध रूप से रखने के लिए, mv उत्पन्न करने का कोई भी तरीका पहले से ही s को संकलक द्वारा हुड के तहत सौंपा गया होगा। एक मानक तरीका दाहिने हाथ की ओर तो Data.Vector.Unboxed से एक 'शुद्ध' वेक्टर पर इस तरह के एक समारोह में कार्य करने के लिए,, .Mutable मॉड्यूल

import qualified Data.Vector.Unboxed as UV 
import qualified Data.Vector.Unboxed.Mutable as MV 
import Control.Monad.ST 

myRead :: MV.Unbox a => UV.Vector a -> a 
myRead v = runST $ do mv <- UV.unsafeThaw v 
         MV.read mv 0 

बेशक

से आपरेशन लागू करने से पहले यह पिघलना है, इस विशेष परिभाषा बराबर है myRead = (UV.! 0) इसी तरह करने के लिए, कुछ इस तरह मतलब होता है, myRead

mhead :: MV.Unbox a => MV.MVector s a -> ST s a 
mhead mv0 = MV.read mv0 0 

mrx = runST $ do mv <- UV.unsafeThaw $ UV.enumFromStepN 0 1 20 
          -- ^^^ or however the mv is generated. 
        x <- MV.unsafeRead mv 17 -- arbitrary 'scratch pad' 
        MV.unsafeWrite mv 17 (2*x) -- computations 
        mhead mv 
        -- ^^^ we return just the first element, after all the mutation 

की परिभाषा में runST हड़ताली यहाँ, बजाय runST साथ myRead या mhead बंद बंद करने हम मैं रखना s में टी polymorphic और फिर उसी ST ब्लॉक के अंदर इसका उपयोग कर सकते हैं जिसमें परिवर्तनीय वेक्टर mv प्रकट होता है। इस प्रकार संकलक 'गुप्त' s का उपयोग करने में सक्षम होंगे, जो mhead को mv पर लागू करने के परिणाम की व्याख्या करने के लिए संपूर्ण रूप से डू-ब्लॉक के लिए उपयोग कर रहा है, क्योंकि यह mhead

की हमारी बहुलक परिभाषा द्वारा खोले गए संभावनाओं में से एक है

Answer 3

आवेदक द्वारा उत्तर आपको संकलित करने के लिए अपना कोड कैसे प्राप्त करें, बताता है। लेकिन कोड प्रयोग योग्य नहीं होगा: runST का बिंदु यह है कि अनिवार्य गणना बाध्य प्रकार चर के कारण अनिवार्य गणना इसे से नहीं बचा सकती है।

अब किसी भी परिवर्तनशील सरणी है कि आप कहीं बनाने के एक तय रों के लिए प्रकार MVector s a होगा, जबकि अपनी myRead कि किसी भी रों के लिए एक वेक्टर प्रदान करता है एक मूल्य की उम्मीद है।

ऐसा लगता है कि पहले एक समस्या है जिससे आप उस (असंभव) कार्य को प्राप्त करना चाहते हैं।