ParseSKI.hs

module ParseSKI ( parseSKI ) where

import SKI

import Text.Parsec
import Text.ParserCombinators.Parsec.Language
import qualified Text.Parsec.Token as Tok

type P = Parsec String ()

lexer :: Tok.TokenParser u
lexer = Tok.makeTokenParser emptyDef

parens :: P a -> P a
parens = Tok.parens lexer

whiteSpace :: P ()
whiteSpace = Tok.whiteSpace lexer

symbol :: String -> P String
symbol = Tok.symbol lexer

parseS :: P SKI
parseS = symbol "S" >> return S

parseK :: P SKI
parseK = symbol "K" >> return K

parseI :: P SKI
parseI = symbol "I" >> return I

atom :: P SKI
atom = parseS <|> parseK <|> parseI <|> parens app

app :: P SKI
app = do  f <- atom
          args <- many atom
          return (foldl App f args)

ski :: P SKI
ski = app

parseSKI :: P SKI
parseSKI = ski

runpSKI :: String -> SKI
runpSKI s = case runParser (whiteSpace *> ski <* eof) () "" s of
              Right t -> t
              Left e -> error $ show e