Применение типов

    cc           :: (String b) => [String] -> b
    cc (a:"*":b:t) = cc(c:t)
    where c=show(read a * read b)
    cc (a:"/":b:t) = cc(c1:t)
    where c1=show(read a / read b)
    cc (a:"-":t) = show(read a - read(cc t))
    cc (a:"+":t) = show(read a + read (cc t))
    cc (a:[])    = a
    cc []    = 0
 
ERROR file:.\e3.hs:18 - Undefined class "String"

parse :: String -> Double
parse xs = case span (`notElem` "+-") xs of
    (y, '+':ys)     -> parse y + parse ys
    (y, '-':ys)     -> parse y - parse ys
    (y, _     )     -> case span (`notElem` "*/") y of
        (x, '*':xs) -> parse x * parse xs
        (x, '/':xs) -> parse x / parse xs
        (x, _     ) -> read x

> parse "2+3+3*2+2"
13.0

> parse "2+3+3*2+2/2"
12.0

parse :: Bool -> String -> Double
parse b xs = case span (`notElem` "+-") xs of
    (y, x:ys)     -> parse b y + parse (x == '+') ys
    (y, _     )     -> case span (`notElem` "*/") y of
        (x, '*':xs) -> parse b x * parse True xs
        (x, '/':xs) -> parse b x / parse True xs
        ([],_     ) -> 0
        (x, _     ) -> read x * (if b then 1 else -1)
 
calc = parse True

parse :: Bool -> Bool -> String -> Double
parse b1 b2 xs = case span (`notElem` "+-") xs of
    (y, x:ys  )     -> parse b1 b2 y + parse (x == '+') True ys
    (y, _     )     -> case span (`notElem` "*/") y of
        (y, x:xs  ) -> parse b1 b2 y * parse True (x == '*') xs
        ([],_     ) -> 0
        (x, _     )
            | b1 && b2     ->        read x
            | b2           -> (-1) * read x
            | b1 && not b2 ->   1  / read x
            | otherwise    ->  -1  / read x
 
calc = parse True True

parse :: String -> String -> [String] -> [String]
parse [] lex r = if (lex /= "") then r ++ [lex] else r
parse (x:xs) lex r | ((x == '*') || (x == '/') || (x == '+') || (x == '-') || (x == '(') || (x == ')')) = 
                       if (length lex) > 0 then parse xs [] (r ++ [lex] ++ [[x]]) else parse xs [] (r ++ [[x]])
                   | otherwise = (parse xs (lex ++ [x]) r)
                   
prty :: String -> Int
prty "(" = 0
prty "+" = 1
prty "-" = 1
prty "*" = 2
prty "/" = 2
prty _   = error "!"
 
lexType :: String -> Int
lexType x | (x `elem` ["(",")","+","-","*","/"]) = 1
          | otherwise = 0
     
emptyP :: [String] -> [String] -> [[String]]
emptyP (o:os) inin@(n:ns) | (o == "(") = [os,inin]
                          | otherwise = emptyP os ((exec (head ns) n o) : (tail ns))
 
empty :: [String] -> [String] -> String
empty [] n = (head n)
empty (o:os) (n:ns) = empty os ((exec (head ns) n o) : (tail ns))                          
     
exec :: String -> String -> String -> String
exec a1 a2 "+" = show ((read a1) + (read a2))          
exec a1 a2 "-" = show ((read a1) - (read a2))          
exec a1 a2 "*" = show ((read a1) * (read a2))          
exec a1 a2 "/" = show ((read a1) `div` (read a2)) 
         
calcF :: [String] -> [String] -> [String] -> String
calcF [] s1 [] = head s1
calcF [] s1 s2 = empty s2 s1
calcF (l:ls) s1 s2 | (lexType l) == 0 = calcF ls (l:s1) s2
                   | (l == "(")       = calcF ls s1 ("(" : s2)
                   | (l == ")")       = calcF ls q1 q2
                   | (s2 == [])       = calcF ls s1 [l]
                   | (prty l) <= (prty (head s2)) = calcF (l:ls) ((exec (s1 !! 1) (s1 !! 0) (head s2)):(drop 2 s1)) (tail s2)
                   | otherwise = calcF ls s1 (l:s2)
                     where tmp=(emptyP s2 s1); q1=(tmp !! 1); q2=(tmp !! 0);
                   
calc :: String -> String
calc x = calcF (parse x "" []) [] []
 
-- Проверка
 
*Main> calc "23-5*(6-(10+5)+10)-20+5"
 
"3"
 
*Main> calc "1/2/5"
 
"0"
 
*Main> calc "2+3+3*2+2"
 
"13"
 
*Main> calc "2+3+3*2+2/2"
 
"12"
 
*Main> calc "3+100/10/2/5-4-4/2"
 
"-2"