खोज…


परिचय

Attoparsec एक पार्सिंग कॉम्बीनेटर लाइब्रेरी है जो "विशेष रूप से नेटवर्क प्रोटोकॉल और जटिल पाठ / बाइनरी फॉर्मेट फॉर्मेट के साथ कुशलता से निपटने के उद्देश्य से है"।

Attoparsec न केवल गति और दक्षता प्रदान करता है, बल्कि पीछे और वृद्धिशील इनपुट भी प्रदान करता है।

इसका एपीआई बारीकी से एक और पार्सर कॉम्बीनेटर लाइब्रेरी, पारसेक का दर्पण है।

ByteString , Text और Char8 ByteString के साथ संगतता के लिए Char8OverloadedStrings भाषा एक्सटेंशन का उपयोग करने की सिफारिश की जाती है।

पैरामीटर

प्रकार विस्तार
Parser ia एक पार्सर का प्रतिनिधित्व करने के लिए मुख्य प्रकार। i स्ट्रिंग प्रकार है, उदाहरण के लिए ByteString
IResult ir एक पार्स, साथ का परिणाम Fail i [String] String , Partial (i -> IResult ir) और Done ir कंस्ट्रक्टर्स के रूप में।

combinators

पार्सिंग इनपुट को सबसे बड़े पार्सर कार्यों के माध्यम से प्राप्त किया जाता है जो छोटे, एकल उद्देश्य वाले होते हैं।

मान लें कि हम निम्नलिखित पाठ को पार्स करना चाहते हैं जो काम के घंटों का प्रतिनिधित्व करता है:

सोमवार: 0800 1600।

हम इन्हें दो "टोकन" में विभाजित कर सकते हैं: दिन का नाम - "सोमवार" - और एक समय भाग "0800" से "1600"।

एक दिन के नाम को पार्स करने के लिए, हम निम्नलिखित लिख सकते हैं:

data Day = Day String

day :: Parser Day
day = do
  name <- takeWhile1 (/= ':')
  skipMany1 (char ':')
  skipSpace
  return $ Day name

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

data TimePortion = TimePortion String String

time = do
    start <- takeWhile1 isDigit
    skipSpace
    end <- takeWhile1 isDigit
    return $ TimePortion start end

अब हमारे पास पाठ के अलग-अलग हिस्सों के लिए दो पार्सर हैं, हम पूरे दिन के काम के घंटे पढ़ने के लिए इन्हें "बड़े" पार्सर में जोड़ सकते हैं:

data WorkPeriod = WorkPeriod Day TimePortion

work = do
    d <- day
    t <- time
    return $ WorkPeriod d t
    

और फिर पार्सर चलाएं:

parseOnly work "Monday: 0800 1600"

बिटमैप - बाइनरी डेटा को पार्स करना

Attoparsec बाइनरी डेटा को तुच्छ बना देता है। इन परिभाषाओं को मानते हुए:

import           Data.Attoparsec.ByteString (Parser, eitherResult, parse, take)
import           Data.Binary.Get            (getWord32le, runGet)
import           Data.ByteString            (ByteString, readFile)
import           Data.ByteString.Char8      (unpack)
import           Data.ByteString.Lazy       (fromStrict)
import           Prelude                    hiding (readFile, take)

-- The DIB section from a bitmap header
data DIB = BM | BA | CI | CP | IC | PT
           deriving (Show, Read)

type Reserved = ByteString

-- The entire bitmap header
data Header = Header DIB Int Reserved Reserved Int
              deriving (Show)

हम एक बिटमैप फ़ाइल से हेडर को आसानी से पार्स कर सकते हैं। यहां, हमारे पास 4 पार्सर फ़ंक्शन हैं जो एक बिटमैप फ़ाइल से हेडर अनुभाग का प्रतिनिधित्व करते हैं:

सबसे पहले, DIB सेक्शन को पहले 2 बाइट्स ले कर पढ़ा जा सकता है

dibP :: Parser DIB
dibP = read . unpack <$> take 2

इसी तरह, बिटमैप के आकार, आरक्षित वर्गों और पिक्सेल ऑफसेट को भी आसानी से पढ़ा जा सकता है:

sizeP :: Parser Int
sizeP = fromIntegral . runGet getWord32le . fromStrict <$> take 4

reservedP :: Parser Reserved
reservedP = take 2

addressP :: Parser Int
addressP = fromIntegral . runGet getWord32le . fromStrict <$> take 4

जो तब पूरे हेडर के लिए एक बड़े पार्सर फ़ंक्शन में जोड़ा जा सकता है:

bitmapHeader :: Parser Header
bitmapHeader = do
    dib <- dibP
    sz <- sizeP
    reservedP
    reservedP
    offset <- addressP
    return $ Header dib sz "" "" offset


Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow