About.me

• Systems analyst
• Translator
• PL researcher
• Developer of Quack and Capybara programming languages 

do latim...

Pars (ōrātiōnis)

Parte (de uma linguagem)

λ. O que é um parser

• Base de um compilador

• Análise sintática baseada em uma gramática

• Construção de linguagens

λ. O que é um parser

LEXER

λ. O que é um parser ─ quebrando o front-end de um compilador

var x = 10 + 20 * 30;

• Divide o texto em um conjunto de tokens

• Classifica-os com tags e talvez valores

• “Alimenta” o parser

PARSER

λ. O que é um parser ─ quebrando o front-end de um compilador

var x = 10 + 20 * 30;

• Consome tokens

• Possui uma gramática

• Pode gerar uma árvore sintática

ÁRVORE SINTÁTICA

λ. O que é um parser ─ quebrando o front-end de um compilador

var x = 10 + 20 * 30;

• Árvore representa o programa

• Análise semântica

• Pode gerar código

GRAMÁTICA FORMAL

λ. O que é um parser ─ projetando linguagens

• Definição formal de uma linguagem

• Conjunto de regras e produções que a validam

O que é um parser generator?

λ. Parser generators × parser combinators ─ parser generators

• Ferramenta que recebe uma linguagem formal e dá o código fonte de um parser como saída

• Grande parte das linguagens modernas são escritas usando parser generators

Exemplos de parser generators

λ. Parser generators × parser combinators ─ parser generators

• ANTLR (Groovy, Jython)

• Bison (Ruby, PHP, Go, Bash, MySQL)

O que é um parser combinator?

λ. Parser generators × parser combinators ─ parser combinators

• Função de mais alta ordem que aceita vários parsers de entrada e dá outro como saída

• Parsers são compostos sempre através de outros parsers, tudo de maneira combinada

O que é um parser combinator?

λ. Parser generators × parser combinators ─ parser combinators

• Parser combinators são legíveis, modulares, bem estruturados e fáceis de manter

• Não são dependentes de um lexer, em sua maioria

Exemplos de parser combinators

λ. Parser generators × parser combinators ─ parser combinators

• Parsec (for Haskell)

• Parsimmon (for JavaScript)

Parsec é um

parser
combinator!

Que tal o Parsec?

λ. Que tal o Parsec?

• Poderoso combinador monádico de parsers para Haskell

• Analisa gramáticas sensíveis ao contexto, finitas ou infinitas

Que tal o Parsec?

λ. Que tal o Parsec?

• Combine parsers e crie expressões maiores

• Existem ports para JS, Python, OCaml, Java, F# e mais uma dezena de linguagens

module JSON where
{-# LANGUAGE NoMonomorphismRestriction #-}

-- Precisamos para mostrar o JSON
import Data.List (foldl', intersperse)
-- Analisar sequências de escape
import Data.Char (chr, ord)
-- Representar arrays associativos
import qualified Data.Map as Map

import Text.Parsec
import Text.Parsec.Char

λ. Que tal o Parsec? ─ Construindo um parser de JSON

Import stuff...

-- Transformar um JSON em uma string para exibição
instance Show JSON where
    showsPrec _ = showsJSON where
        commaJoin                =
            foldl' (.) id . intersperse (", " ++)

        showsAssoc (field, val)  =
            shows field . (": " ++) . shows val

        showsJSON (JsonNum num)  =
            shows num

        showsJSON (JsonStr str)  =
            shows str

        showsJSON (JsonArr jarr) =
            ('[' :) .
            commaJoin (map shows jarr) .
            (']' :)

        showsJSON (JsonAA aa)    =
            ('{' :) .
            commaJoin (map showsAssoc $ Map.toList aa) .
            ('}' :)

        showsJSON (JsonBool tf)  =
            if tf then ("true" ++) else ("false" ++)

        showsJSON JsonNull       =
            ("null" ++)

λ. Que tal o Parsec? ─ Construindo um parser de JSON

Criamos uma função para exibição do JSON

jsonPNull = try (string "null")
         >> return JsonNull

λ. Que tal o Parsec? ─ Construindo um parser de JSON

JSON pode conter valores nulos, certo?

jsonPNum = do
    -- Uma função que pode negar nosso resultado
    doNeg <- (char '-' >> return negate) <|> return id
    -- Todo número pode...
    realPart <- realP
    fracPart <- fracP
    expPart  <- expP

    return $ JsonNum $ doNeg $ (realPart + fracPart) * 10 ** expPart
        -- Parte real do número. Deve existir
  where realP = (char '0' >> return 0) <|> (do
                -- 0 ou entre 1 a 9
                firstDigit <- satisfy (\ ch -> '1' <= ch && ch <= '9')
                -- Depois, quaisquer digitos
                restDigits <- many digit
                return $ read $ firstDigit : restDigits
            )
        fracP = (do
                char '.'
                digits <- many1 digit
                return $ read $ "0." ++ digits
            )
            -- Se não há um (.), o padrão é 0.
            <|> return 0
        expP = (do
            oneOf "eE"
            -- É opcional a notação exponencial
            doNeg <- (char '-' >> return negate)
                <|> (char '+' >> return id)
                <|> return id
            digits <- many1 digit
            return $ doNeg $ read digits
            )
            -- 0 é padrão para a notação exponencial
            <|> return 0

λ. Que tal o Parsec? ─ Construindo um parser de JSON

Números são um pouco mais complexos...

-- Somente listas de valores JSON separados por
-- vírgulas!
jsonPArr = do
    char '['
    jarr <- jsonParser `sepBy` (char ',')
    char ']'
    return $ JsonArr $ jarr

λ. Que tal o Parsec? ─ Construindo um parser de JSON

Que tal representarmos arrays simples?

-- Podemos até fazer um mini-REPL!
main = do
    line <- getLine
    case parse jsonParser "" line of
        Right json -> do
            print json
            main
        Left err -> print err

λ. Que tal o Parsec? ─ Construindo um parser de JSON

Sério? Um parser de JSON em 100 linhas?

E como usamos?

λ. Referências & recomendações

• Parsec ─ HaskellWiki

• Real world Haskell ─ Using Parsec

slides.com/marcelocamargo/parsec

• Compilers: principles, techniques and tools

• Let's build a compiler!