पाओला का प्रतिष्ठित पिज़्ज़ा

पार्सिंग

पार्सिंग वह प्रक्रिया है जिसमें टेक्स्ट को अर्थपूर्ण डेटा में बदला जाता है। इस मामले में String पैकेज के फंक्शन सीमित हैं और रेगुलर एक्सप्रेशन इस्तेमाल करना मुश्किल है, इसलिए Elm में पार्स करने का स्वाभाविक तरीका elm/parser पैकेज इस्तेमाल करना है।

चलिए प्रोग्रामिंग भाषा LOLCODE के एक हिस्से के लिए पार्सर लिखने का एक उदाहरण देखते हैं। आइए नीचे दिए गए टिप्पणियों वाले प्रोग्राम को देखें:

HAI 1                 # program version 1
CAN HAS STDIO?        # import stdio
VISIBLE "HAI WORLD!"  # print "HAI WORLD!"
KTHXBYE               # end of program

सबसे पहले, संभावित कमांड को दर्शाने के लिए एक Elm टाइप लिखते हैं:

type Command
    = Version Int
    | Import String
    | Print String

इसके बाद हमारे LOLCODE प्रोग्राम को List Command के रूप में बनाया जा सकता है। चलिए HAI 1 लाइन के लिए एक पार्सर से शुरू करते हैं:

versionP : Parser Command
versionP =
    Parser.succeed Version
        |. Parser.keyword "HAI"
        |. Parser.spaces
        |= Parser.int

versionP को एक पार्सर पाइपलाइन की मदद से बनाया गया है। (|.) ऑपरेटर का मतलब है "स्ट्रिंग को पार्स कीजिए, पर नतीजा छोड़ दीजिए" और (|=) का मतलब है "स्ट्रिंग को पार्स कीजिए और नतीजा रख लीजिए"। इस उदाहरण में, Parser.keyword "HAI" एक "HAI" पढ़ेगा, पर उस नतीजे को अनदेखा कर दिया जाता है। Parser.spaces कितने भी ' ', '\n', और '\r' अक्षर पढ़ लेगा, पर उसे भी अनदेखा कर दिया जाएगा। Parser.int एक पूर्णांक पार्स करेगा, और उस पूर्णांक की वैल्यू (मान लीजिए 1) सबसे ऊपर वाले Parser.succeed Version को दी जाएगी, और पार्सर Version 1 वैल्यू लौटाने में सफल होगा।

अगर पाइपलाइन का कोई भी पार्सर फेल हो जाए, तो वह एक Parser.DeadEnd लौटाता है और पूरा पार्सर फेल हो जाता है। किसी पार्सर को Parser.run की मदद से चलाया जा सकता है:

Parser.run versionP "HAI 1"
    --> Ok (Version 1)
Parser.run versionP "HAI 2"
    --> Ok (Version 2)
Parser.run versionP "BYE 2"
    --> Err [{ problem = ExpectingKeyword "HAI", col = 1, row = 1 }]
Parser.run versionP "HAI MOM"
    --> Err [{ problem = ExpectingInt, col = 5, row = 1 }]

चलिए अब "CAN HAS STDIO?" लाइन पर काम करते हैं:

importP : Parser Command
importP =
    Parser.succeed Import
        |. Parser.keyword "CAN HAS"
        |. Parser.spaces
        |= packageP
        |. Parser.symbol "?"

importP भी एक पार्सर पाइपलाइन है, पर इस बार यह Parser.symbol पर खत्म होती है, जो "?" जैसे सिंबल पार्स करने के लिए उपयुक्त है। जिस वैल्यू को हम रखना चाहते हैं (जिस पैकेज को इम्पोर्ट करना है उसका नाम), उसे इस तरह पार्स किया जाता है:

packageP : Parser String
packageP =
    Parser.chompWhile Char.isAlphaNum
        |> Parser.getChompedString
        |> Parser.map String.toLower

चूँकि हमें नहीं पता कि पैकेज का नाम क्या होगा, इसलिए हम Parser.keyword इस्तेमाल नहीं कर सकते। इसकी जगह हम Parser.chompWhile इस्तेमाल करते हैं, जो तब तक एक-एक अक्षर पढ़ता है जब तक वे किसी शर्त को पूरा करते हैं (यहाँ शर्त है अल्फान्यूमेरिक अक्षर होना)। इस तरह पढ़े गए अक्षरों को Parser.getChompedString इकट्ठा करता है, जो एक Parser String लौटाता है। यहाँ हम पैकेज के नाम सामान्य रूप में लाना चाहते हैं, इसलिए हम Parser.map की मदद से पार्सर में मौजूद स्ट्रिंग को बदलकर छोटे अक्षरों में कर देते हैं।

Parser.run importP "CAN HAS STDIO?"
    --> Ok (Import "stdio")
Parser.run importP "CAN HAS StDiO?"
    --> Ok (Import "stdio")
Parser.run importP "CAN HAS STDIO"
    -->  Err [{ problem = ExpectingSymbol "?", col = 14, row = 1 }]

अब बारी है VISIBLE "HAI WORLD!" की, जिसे इस तरह पार्स किया जाता है:

printP : Parser Command
printP =
    Parser.succeed Print
        |. Parser.keyword "VISIBLE"
        |. Parser.spaces
        |. Parser.symbol "\""
        |= stringP
        |. Parser.symbol "\""

stringP : Parser String
stringP =
    Parser.chompWhile (\c -> c /= '"')
        |> Parser.getChompedString

Parser.run printP "VISIBLE \"HAI WORLD!\""
    --> Ok (Print "HAI WORLD!")

अब हमारे पास हर कमांड के लिए एक पार्सर है। बेशक, किसी भी सामान्य प्रोग्राम में इन कमांड का क्रम पहले से नहीं बताया जा सकता, इसलिए हम एक सामान्य कमांड पार्सर बनाते हैं:

commandP : Parser Command
commandP =
    Parser.oneOf
        [ versionP
        , importP
        , printP
        ]

Parser.oneOf दिए गए क्रम में एक-एक पार्सर आज़माता है। अगर कोई पार्सर फेल हो जाता है, तो अगला आज़माया जाता है, पर अगर वह सफल हो जाता है, तो उसका नतीजा लौटा दिया जाता है और बाकी पार्सर आज़माए ही नहीं जाते। अगर सारे पार्सर फेल हो जाएँ, तो Parser.oneOf भी फेल हो जाता है।

Parser.run commandP "HAI 2"
    --> Ok (Version 2)
Parser.run commandP "CAN HAS STDIO?"
    --> Ok (Import "stdio")
Parser.run commandP "VISIBLE \"HAI WORLD!\""
    --> Ok (Print "HAI WORLD!")
Parser.run commandP "O NOES"
    --> Err [ { problem = ExpectingKeyword "HAI", col = 1, row = 1 }
    --      , { problem = ExpectingKeyword "CAN HAS", col = 1, row = 1 }
    --      , { problem = ExpectingKeyword "VISIBLE", col = 1, row = 1 }
    --      ]

ध्यान दीजिए कि हर फेल होने वाली कोशिश एक Parser.DeadEnd बनाती है, जिसे Parser.oneOf इकट्ठा कर लेता है।

पूरा प्रोग्राम पार्स करने के लिए हमें कई कमांड एक के बाद एक पार्स करने होंगे, इस तरह:

programP : Parser (List Command)
programP =
    Parser.sequence
        { start = ""
        , separator = "\n"
        , end = "KTHXBYE"
        , spaces = Parser.succeed ()
        , item = commandP
        , trailing = Parser.Optional
        }

Parser.sequence बहुत लचीला पार्सर है, जिसमें कई विकल्प मिलते हैं। start, separator और end वे स्ट्रिंग लेते हैं जो सीक्वेंस के आइटम को अलग करती हैं; Elm की लिस्ट पार्स करने के लिए हम "[", "," और "]" इस्तेमाल करेंगे। spaces लचीलापन देता है, क्योंकि यह एक ऐसा पार्सर लेता है जो आइटम और सेपरेटर के बीच आने वाले संभावित स्पेस सँभाल लेगा; Elm की लिस्ट पार्स करने के लिए हम Parser.spaces इस्तेमाल करेंगे, पर यहाँ हम कोई स्पेस स्वीकार नहीं करते, इसलिए हम Parser.succeed () इस्तेमाल करते हैं, जो बिना कुछ पढ़े तुरंत सफल हो जाता है। item आइटम पार्सर लेता है, और अंत में trailing से हम तय करते हैं कि आखिर में आने वाले सेपरेटर Parser.Forbidden, Parser.Mandatory या Parser.Optional होंगे।

Parser.run programP "HAI 2\nCAN HAS STDIO?\nKTHXBYE"
    --> Ok [Version 2, Import "stdio"]
Parser.run programP "KTHXBYE"
    --> Ok []
Parser.run programP "HAI 2\nCAN HAS STDIO?\n"
    --> Err [ { problem = ExpectingKeyword "HAI", col = 1, row = 3 }
    --      , { problem = ExpectingKeyword "CAN HAS", col = 1, row = 3 }
    --      , { problem = ExpectingKeyword "VISIBLE", col = 1, row = 3 }
    --      , { problem = Expecting "KTHXBYE", col = 1, row = 3 }
    --      ]

जब पार्सर सफल हो जाते हैं, तो वे स्ट्रिंग पढ़ना बंद कर देते हैं:

Parser.run Parser.int "1"
    --> Ok 1
Parser.run Parser.int "1 BTW VISIBLE \"U SEE NOTHING\""
    --> Ok 1

इसलिए अगर हमें यह पक्का करना हो कि स्ट्रिंग में जो कुछ था, वह सब पार्स हो गया, तो हम Parser.end इस्तेमाल कर सकते हैं:

fullProgramP : Parser (List Command)
fullProgramP =
    programP
        |. Parser.spaces
        |. Parser.end

Parser.run fullProgramP "HAI 2\nCAN HAS STDIO?\nKTHXBYE"
    --> Ok [Version 2, Import "stdio"]
Parser.run fullProgramP "HAI 2\nCAN HAS STDIO?\nKTHXBYE\nBTW VISIBLE \"U SEE NOTHING\""
    --> Err [{ problem = ExpectingEnd, col = 1, row = 4 }]

आखिर में, कभी-कभी हमें पार्स किए गए कंटेंट के हिसाब से किसी पार्सर को फेल करने का फैसला लेना पड़ता है। उदाहरण के लिए, अगर हमें ऐसा पार्सर चाहिए जो उन प्रोग्राम को फेल कर दे जो लगातार दो "HAI" कमांड से शुरू होते हैं, तो हम यह लिख सकते हैं:

singleVersionProgramP : Parser (List Command)
singleVersionProgramP =
    fullProgramP
        |> Parser.andThen
            (\commands ->
                case commands of
                    (Version _) :: (Version _) :: _ ->
                        Parser.problem "Multiple versions defined"

                    _ ->
                        Parser.succeed commands
            )

Parser.andThen किसी पार्सर के कंटेंट को जाँच सकता है और उसकी वैल्यू के हिसाब से एक नया पार्सर लौटाता है। यहाँ हमने एक स्थिति में Parser.problem की मदद से अपना संदेश देकर पार्सर फेल किया, और दूसरी स्थिति में मूल वैल्यू लौटा दी।

Parser.run singleVersionProgramP "HAI 2\nCAN HAS STDIO?\nKTHXBYE"
    --> Ok [Version 2, Import "stdio"]
Parser.run singleVersionProgramP "HAI 1\nHAI 2\nCAN HAS STDIO?\nKTHXBYE"
    --> Err [{ problem = Problem "Multiple versions defined", col = 8, row = 4 }]