Paola의 명성 높은 피자

파싱

파싱은 텍스트를 의미 있는 데이터로 변환하는 과정이에요. 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 String을 반환하는 Parser.getChompedString으로 모여요. 이 경우 패키지 이름을 정규화하고 싶어서, 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.oneOf가 모으는 Parser.DeadEnd를 만들어낸다는 점에 주목해요.

전체 프로그램을 파싱하려면 여러 명령을 순차적으로 파싱해야 하는데, 다음과 같이 해요.

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 }]