পাওলার বিখ্যাত পিৎজা

পার্সিং

পার্সিং হলো টেক্সটকে অর্থবহ ডেটায় রূপান্তর করার প্রক্রিয়া। এই ব্যাপারে 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 }]