module FunParser where {

import Text.ParserCombinators.Parsec;
import Text.ParserCombinators.Parsec.Expr;
import Token;
import FunType;

parseExpr = buildExpressionParser table parseFactor <?> "expression";

table = [
         [ Infix (do { reservedOp "*"; return Mult }) AssocLeft],
         [ Infix (do { reservedOp "+"; return Add }) AssocLeft]
        ];

parseFactor = do {
                  es <- many1 parseAtomic;
                  return (foldl1 App es)
                 }
;

parseAtomic = parens parseExpr
              <|>
              (do { t <- naturalOrFloat;
                    return (case t of { Left i -> Const (Num (fromInteger i));
                                        Right d -> Const (Num d) }) })
              <|>
              (do { t <- identifier; return (Var t) })
              <|>
              (do { reserved "let";
--                  decls <- parseDecls;
                    decl <- parseDecl;
                    reserved "in";
                    expr  <- parseExpr;
--                  return (Let decls expr)
                    return (Let decl expr)
                  })
              <|>
              (do { (reserved "fn" <|> reservedOp "\\");
                    id <- identifier;
                    reservedOp "->";
                    e <- parseExpr;
                    return (Lambda id e)
                  })
;

parseDecls = sepBy1 parseDecl semi;
parseDecl = do {
                i <- identifier;
                reservedOp "=";
                e <- parseExpr;
                return (i, e)
               }
;

myParse :: String -> Expr;
myParse str = case
                (parse (do {whiteSpace; s<- parseExpr; eof; return s }) "" str)
              of {
                Left err -> Const (Num (1/0));
                Right x  -> x
              };
}