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

    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 :: 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 = par.filter (/= ' ')
 
par x = case span (/=')') x of
    (l, ')':xs) -> case span (/='(') (reverse l) of
        (l, '(':ys) -> par $ reverse ys ++ show (parse True True (reverse l)) ++ xs
    (l, _)      -> parse True True l

parse :: String -> String -> [String] -> [String]
parse [] lex r = if (lex /= "") then r ++ [lex] else r
parse (x:xs) lex r | ( x `elem` "+-*/^()") = 
                       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 "^" = 3
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)) 
exec a1 a2 "^" = show ((read a1) ^ (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 "3+4^3"
"67"
Main> calc "(3+4)^3"
"343"

(calc "2^3^2",2^3^2)