Lesen Klammern und Negation

Question

Mein Ziel ist es, einen Rechner in Haskell mit Text.ParserCombinators.ReadP, die +, -, *, /, ^, sowie Negation implementiert, und folgt PEMDAS. Zuerst muss ich eine String-Eingabe für einen mathematischen Ausdruck analysieren (MathExp). Ein Teil des Code, den ich habe, ist wie folgt:

import Control.Applicative hiding (many) 
import Control.Monad 
import Data.Char 
import Data.List 
import Data.Ord 
import Text.ParserCombinators.Readp 
type Name = String 
type Number = Int  

data MathExp 
    = Number Number 
    | Neg MathExp 
    | Plus MathExp MathExp 
    | Minus MathExp MathExp 
    | Mult MathExp MathExp 
    | Div MathExp MathExp 
    | Pow MathExp MathExp 
    | Var String 
    deriving (Eq, Show) 

parseNumber :: ReadP MathExp 
parseNumber = do 
    skipSpaces 
    x <- munch1 isDigit 
    return (Number (read x :: Int)) 

parsePlus :: ReadP (MathExp -> MathExp -> MathExp) 
parsePlus = do 
    x <- char '+' 
    return Plus 

parseMinus :: ReadP (MathExp -> MathExp -> MathExp) 
parseMinus = do 
    skipSpaces 
    x <- char '-' 
    return Minus 

parsePlusMinus = choice [parsePlus, parseMinus] --parse both-- 

parseMult :: ReadP (MathExp -> MathExp -> MathExp) 
parseMult = do 
    x <- char '*' 
    return Mult 

parseDiv :: ReadP (MathExp -> MathExp -> MathExp) 
parseDiv = do 
    x <- char '/' 
    return Div 

parseMultDiv = choice [parseMult, parseDiv] --parse both M,D-- 
parsePow :: ReadP (MathExp -> MathExp -> MathExp) 
parsePow = do 
    x <- char '^' 
    return Pow 

parseNeg :: ReadP MathExp 
parseNeg = undefined 
parseParens = undefined 

Ich habe kein Problem, die Parser kombiniert ich derzeit habe, mit chainl1 und chainr1, Assoziativität und Vorrang in der richtigen Reihenfolge zu implementieren, aber ich habe keine Ahnung, wie man Negation und Klammern richtig implementieren.

Was ich weiß, wenn diese Negation auch ein - Zeichen ist, und es kann entweder vor einer Ganzzahl, Klammern oder einer Variablen (Buchstabenfolge) stehen. Die Variablen sind ein weiterer Teil des Rechners (ich habe keine Probleme mit). Darüber hinaus kann eine Negation einen Leerraum enthalten; zum Beispiel 1+2* - 3 ist ein gültiger String-Eingang für diesen Rechner.

Answer 1

Sie können wie folgt tun:

import Control.Applicative 
import Data.Char 
import Text.ParserCombinators.ReadP 

type Name = String 
type Number = Int 

data MathExp 
    = Number Number 
    | Neg MathExp 
    | Plus MathExp MathExp 
    | Minus MathExp MathExp 
    | Mult MathExp MathExp 
    | Div MathExp MathExp 
    | Pow MathExp MathExp 
    | Var Name 
    deriving (Eq, Show) 

runParser :: ReadP a -> String -> Maybe a 
runParser p s = 
    case readP_to_S p s of 
     [(x, [])] -> Just x 
     _   -> Nothing 

mathExp = mathExp' <* skipSpaces <* eof 
mathExp' = term `chainl1` addop 
term  = factor `chainl1` mulop 
factor = expo `chainr1` expop 
expo  = number <|> var <|> parens mathExp' <|> neg expo 

number = skipSpaces *> (Number . read <$> munch1 isDigit) 
var = skipSpaces *> (Var <$> munch1 isAlpha) 
addop = skipSpaces *> (Plus <$ char '+' <|> Minus <$ char '-') 
mulop = skipSpaces *> (Mult <$ char '*' <|> Div <$ char '/') 
expop = skipSpaces *> (Pow <$ char '^') 
neg p = skipSpaces *> (Neg <$> (char '-' *> p)) 

parens = between (skipSpaces *> char '(') (skipSpaces *> char ')') 

main = print $ runParser mathExp "1+2* - 3" 

Ausgang wird sein:

Just (Plus (Number 1) (Mult (Number 2) (Neg (Number 3))))