La prestigiosa pizza de Paola

Parseo

El parseo es el proceso de transformar texto en datos con significado. Las funciones del paquete String resultan limitadas para eso y las expresiones regulares son difíciles de usar, así que la forma idiomática de parsear en Elm es con el paquete elm/parser.

Veamos un ejemplo en el que escribimos un parser para (un subconjunto de) el lenguaje de programación LOLCODE. Vamos a ver el siguiente programa comentado:

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

Primero, escribamos un tipo de Elm que represente los posibles comandos:

type Command
    = Version Int
    | Import String
    | Print String

Nuestro programa LOLCODE se puede modelar entonces como un List Command. Empecemos con un parser para la línea HAI 1:

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

versionP se construye usando un pipeline de parsers. El operador (|.) significa «parsear el string pero descartar el resultado» y (|=) significa «parsear el string y quedarse con el resultado». En este ejemplo, Parser.keyword "HAI" consumirá un «HAI», pero ese resultado se ignora. Parser.spaces consumirá cualquier número de caracteres ' ', '\n' y '\r', pero eso también se ignorará. Parser.int parseará un número entero, y el valor de ese entero (por ejemplo, 1) se pasará al Parser.succeed Version de más arriba y el parser conseguirá devolver el valor Version 1.

Si uno cualquiera de los parsers del pipeline falla, devolverá un Parser.DeadEnd y todo el parser fallará. Un parser se puede ejecutar con 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 }]

Abordemos la línea «CAN HAS STDIO?» con

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

importP también es un pipeline de parsers, pero esta vez termina con Parser.symbol, que es adecuado para parsear símbolos como «?». El valor que queremos conservar (el nombre del paquete que hay que importar) lo parsea

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

Como no sabemos cuál será el nombre del paquete, no podemos usar Parser.keyword, así que en su lugar usamos Parser.chompWhile, que consumirá caracteres uno a uno siempre que cumplan una condición (en este caso, ser un carácter alfanumérico). Esos caracteres consumidos los recoge después Parser.getChompedString, que devuelve un Parser String. En este caso, queremos normalizar los nombres de los paquetes, así que usamos Parser.map para modificar el string que contiene el parser y ponerlo en minúsculas.

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

A continuación, VISIBLE "HAI WORLD!" se parsea con

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!")

Ya tenemos un parser para cada comando. Por supuesto, en un programa general no se puede predecir el orden de estos comandos, así que construimos un parser de comandos genérico

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

Parser.oneOf probará un parser, en el orden dado. Si un parser falla, se prueba el siguiente, pero si tiene éxito, se devuelve su resultado sin probar los parsers restantes. Si todos los parsers fallan, Parser.oneOf falla.

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

Fíjate en que cada intento fallido produce un Parser.DeadEnd que Parser.oneOf recopila.

Para parsear un programa completo, tenemos que parsear varios comandos de forma secuencial con

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

Parser.sequence es un parser muy personalizable con varias opciones. start, separator y end toman strings que separan los elementos de la secuencia; para parsear un array de Elm usaríamos «[», «,» y «]». spaces aporta flexibilidad: recibe un parser que se encargará de los posibles espacios entre elementos y separadores; para parsear un array de Elm usaríamos Parser.spaces, pero en este caso no aceptamos ningún espacio, así que usamos Parser.succeed (), que tiene éxito de inmediato sin consumir nada en realidad. item recibe el parser del elemento y, por último, trailing nos permite decidir si los separadores finales son Parser.Forbidden, Parser.Mandatory o 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 }
    --      ]

Cuando los parsers tienen éxito, dejan de consumir el string

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

Así que, si tenemos que asegurarnos de que hemos parseado todo el string, podemos usar 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 }]

Por último, a veces tenemos que decidir si hacer fallar un parser en función de su contenido ya parseado. Por ejemplo, si necesitáramos un parser que hiciera fallar los programas que empiezan con dos comandos «HAI» seguidos, podríamos usar

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

                    _ ->
                        Parser.succeed commands
            )

Parser.andThen puede inspeccionar el contenido de un parser y devuelve un parser nuevo en función de su valor. Aquí hacemos fallar el parser con un mensaje personalizado usando Parser.problem en un caso, y devolvemos el valor original en el otro.

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