अनबॉक्स्ड परिवर्तनशील सरणी उदाहरण

Question

चलो कहते हैं कि मैं निम्नलिखित प्रकार मिल गया है जाने कैसे बनाएं:

 
MArray (STUArray s) MyType (ST s) 
MArray IOUarray MyType IO 

पल मैं सब कुछ की दुकान के लिए:

 
data MyType = Constructor0 | Constructor1 | Constructor2 
      deriving (Eq,Show,Enum) 

इस तरह के उदाहरणों में से एक बनाने के लिए एक रास्ता है क्योंकि Word8 और IEnum/toEnum से (लपेटा हुआ) रूपांतरण करते हैं, लेकिन यह सही नहीं लगता है। मुझे सख्तता और अनबॉक्सिंग की आवश्यकता है क्योंकि मैं स्मृति में एक बड़ी डेटा संरचना (> 1.2 जीओ) का उपयोग कर रहा हूं, और मैं इसे आलसी लोड नहीं कर सकता। अगर मुझे कोई समाधान नहीं मिला है तो मैं सी ++ में सबकुछ फिर से लागू करने जा रहा हूं, जिसे मैं अपने वर्तमान प्रोजेक्ट से बचाना पसंद करता हूं।

मैंने # हास्केल पर सवाल पूछा है, लेकिन मुझे कोई प्रतिक्रिया नहीं मिली, शायद यह पूछने के दिन का अच्छा समय नहीं था।

Answer 1

सरल कार्यान्वयन मैं के बारे में सोच सकता है: बस fromEnum/toEnum साथ STUArray/IOUArray संचालन लपेट दें।

{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses #-} 

module UnpackedEnumArray (STUEArray, IOUEArray) where 

import Control.Monad.ST 
import Data.Array.Base 
import Data.Array.IO 
import Data.Array.ST 

data STUEArray s i e = STUEArray { fromSTUEArray :: STUArray s i Int } 
instance (Enum e) => MArray (STUEArray s) e (ST s) where 
    getBounds = getBounds . fromSTUEArray 
    getNumElements = getNumElements . fromSTUEArray 
    newArray is = fmap STUEArray . newArray is . fromEnum 
    newArray_ = fmap STUEArray . newArray_ 
    unsafeRead (STUEArray a) = fmap toEnum . unsafeRead a 
    unsafeWrite (STUEArray a) i = unsafeWrite a i . fromEnum 

data IOUEArray i e = IOUEArray { fromIOUEArray :: IOUArray i Int } 
instance (Enum e) => MArray IOUEArray e IO where 
    getBounds = getBounds . fromIOUEArray 
    getNumElements = getNumElements . fromIOUEArray 
    newArray is = fmap IOUEArray . newArray is . fromEnum 
    newArray_ = fmap IOUEArray . newArray_ 
    unsafeRead (IOUEArray a) = fmap toEnum . unsafeRead a 
    unsafeWrite (IOUEArray a) i = unsafeWrite a i . fromEnum 

अब आप

import UnpackedEnumArray 
main = do 
    a <- newArray (0,9) Constructor0 :: IO (IOUEArray Int MyType) 
    getAssocs a >>= print 

इसी तरह, IArray उदाहरणों तुच्छता रूप में अच्छी तरह लिखा जा सकता है सकते हैं।

Answer 2

MArray IOUarray MyType IO के लिए एक उदाहरण बनाना संभव होना चाहिए। MArray IOUarray Bool IO के लिए उदाहरण घोषणा के स्रोत के लिए एक नज़र डालें।

बूल के बाद से Enum और Bounded दोनों का एक उदाहरण है (और भी बहुत कुछ और नहीं) वे शायद उन वर्गों से कार्यों का उपयोग जब उदाहरण बना रही है।

आपको Bounded प्राप्त करना पड़ सकता है लेकिन शायद यह कोई समस्या नहीं है क्योंकि अनबॉक्स किए गए सरणी में केवल निश्चित आकार तत्व हो सकते हैं।

संपादित करें:

this में लेख एक

पढ़ तुम भी enumerations सहित अन्य साधारण प्रकार, के लिए अनबॉक्स्ड सरणियों खुद को लागू कर सकते कर सकते हैं।