Vergleich des benutzerdefinierten Datentyps mit Parametern

Question

Ich lerne Haskell und versuche, dieses Programm zu implementieren. Ich habe einen benutzerdefinierten Datentyp

data CalculatorInput 
    = Exit 
    | Error String 
    | Operator (Int -> Int -> Int) 
    | Number Int 

dann habe ich eine Methode getInput, die einen Wert dieses Typs zurückgibt.

Jetzt bin ich verwirrt, wie man auf Werte dieses Typs versendet. Ich habe eine Methode

simpleCalculator :: Int -> (Int -> Int -> Int) -> IO() 
simpleCalculator ans op = do 
    input <- getInput -- here i got the type as result 
    if input == Exit then return() 
    else if input == Number x then ans = ans op x; print ans 
    else simpleCalculator ans op 

Ich möchte wissen, ob die Eingabe eine Number x

ist

Ich versuchte case auch zu verwenden:

simpleCalculator :: Int -> (Int -> Int -> Int) -> IO() 
simpleCalculator ans op = do 
    input <- getInput -- here i got the type as result 
    --case input of 
    -- Exit -> return() 
    -- Error x -> print x 
    -- Number n -> ans = ans op x; print ans -- getting error here, multiple statement not possible 
    -- _ -> simpleCalculator ans op 

Ich versuchte Instanz Eq auch

zu erstellen

instance Eq CalculatorInput where 
    (==) Exit Exit = True 
    (==) (Number x) (Number y) = x == y 
    (==) _ _ = False 

Wie kann ich benutzerdefinierte Daten vergleichen Typen mit Parametern oder haben mehrere Anweisungen in einem case Zweig?

Answer 1

Sie sind fast auf dem richtigen Weg mit dem nicht funktionierenden Code:

simpleCalculator :: Int -> (Int -> Int -> Int) -> IO() 
simpleCalculator ans op = do 
    input <- getInput -- here i got the type as result 
    case input of 
     Exit -> return() 
     Error x -> print x 
     Number n -> ans = ans op x; print ans 
     _ -> simpleCalculator ans op 

Sie können Nest do Notationen so dass Sie das folgende richtige Programm schreiben:

simpleCalculator :: Int -> (Int -> Int -> Int) -> IO() 
simpleCalculator ans op = do 
    input <- getInput -- here i got the type as result 
    case input of 
     Exit -> return() 
     Error x -> print x 
     Number n -> do 
     let theAns = ans op x 
     print theAns 
     _ -> simpleCalculator ans op 

Wie für die Eq Instanz kann der Compiler die Arbeit für Sie erledigen, indem er derivation verwendet, dh

data CalculatorInput 
    = Exit 
    | Error String 
    | Operator (Int -> Int -> Int) 
    | Number Int 
    deriving Eq 

schreiben

Answer 2

Verwenden Sie case.

simpleCalculator ans op = do 
    input <- getInput -- here i got the type as result 
    case input of 
     Exit -> return() 
     Number x -> print $ans `op` x 
     _ -> simpleCalculator ans op 

Sie können Eq für CalculatorInput nicht ableiten, da die Funktionen nicht Instanzen von Eq sind.