Simple Expression Parser

SimpleExpressionParsing.hs

{-# LANGUAGE OverloadedStrings #-}

import Control.Applicative ((<|>))
import Data.Attoparsec.Text
import System.Environment
import Data.Text

data Expression = Expression Int Op Expression |
                  Value Int
                  deriving (Show)

data Op = Add | Subtract | Divide | Multiply deriving (Show)

{--eval :: Expression -> Int
eval (Expression x Add y)       = x + y
eval (Expression x Subtract y)  = x - y
eval (Expression x Divide y)    = x `quot` y
eval (Expression x Multiply y)  = x * y
--}
parseValue :: Parser Int
parseValue = decimal

parseExpression :: Parser Expression
parseExpression =
       (parseValue >>= \p1 ->
        parseOp >>= \p2 ->
        parseExpression >>= \p3 -> 
        return (Expression p1 p2 p3))

   <|> (parseValue >>= \p1 ->
        return (Value p1))

{--parseExpression :: Parser Expression
parseExpression =
    parseExpression >>= \p1 ->
    parseOp >>= \p2 ->
    decimal >>= \p3 ->
    endOfInput >> (return (Expression' p1 p2 p3))

parseExpression :: Parser Expression
parseExpression =
    decimal >>= \p1 ->
    parseOp >>= \p2 ->
    decimal >>= \p3 ->  
    return (Expression p1 p2 p3)
--}
parseOp :: Parser Op
parseOp = 
        (char '+' >> return Add)
    <|> (char '-' >> return Subtract)
    <|> (char '/' >> return Divide)
    <|> (char '*' >> return Multiply)

test :: String -> IO ()
test string = print (parseOnly parseExpression (pack string))

main :: IO ()
main = do
    args <- getArgs
    (print (parseOnly parseExpression (pack (args !! 0))))