+module testclass
+
+import StdEnv
+
+import Data.Maybe
+import Data.Either
+import Data.Functor
+import Control.Applicative
+import Control.Monad
+import Control.Monad.State
+
+import Text.Parsers.Simple.Chars
+import Text.Parsers.Simple.Core
+
+class parsable a ~b :: a -> Parser Char b
+
+instance parsable IntParse Int where
+ parsable IntParse = foldl (\a d->a*10 + digitToInt d) 0 <$> some pDigit
+
+instance parsable (AltParse a) b | parsable a b where
+ parsable (l |. r) = parsable l <|> parsable r
+
+:: IntParse = IntParse
+:: AltParse a = (|.) infixl 1 a a
+
+Start = 42
+
+
+//:: In a b = (:.) infix 0 a b
+//
+//:: Gram
+// = Lit String
+// | Int
+// | (-.) infixr 2 Gram Gram
+// | (|.) infixl 1 Gram Gram
+// | *! Gram
+// | ?! Gram
+//Lits = foldr1 (|.) o map Lit
+//foldr1 f [x:xs] = foldr f x xs
+//:: Gast
+// = INT Int
+// | LIT String
+// | BIN Gast Gast
+// | OPT (Maybe Gast)
+// | MANY [Gast]
+//
+//parseFromGram :: Gram -> Parser String Gast
+//parseFromGram Int = INT o toInt <$> pSatisfy (\s->toString (toInt s) == s)
+//parseFromGram (Lit i) = LIT <$> pSatisfy ((==)i)
+//parseFromGram (?! g) = OPT <$> optional (parseFromGram g)
+//parseFromGram (*! g) = MANY <$> many (parseFromGram g)
+//parseFromGram (a -. b) = BIN <$> parseFromGram a <*> parseFromGram b
+//parseFromGram (a |. b) = parseFromGram a <|> parseFromGram b
+//
+////Start = runParser (parseFromGram gram) [".","."]
+//Start = printeval <$> parse (parseFromGram gram) ["4","*","2","*","1","*","(","3","^","3","^","3",")"]
+//where
+// gram =
+// let lit = Lit "(" -. expr -. Lit ")"
+// |. Int
+// pow = lit -. ?! (Lit "^" -. pow)
+// fac = pow -. *! (Lits ["*","/"] -. pow)
+// expr = fac -. *! (Lits ["+","-","%"] -. fac)
+// in expr
+//
+// printeval a = (eval a, print a)
+//
+// eval :: Gast -> Maybe Int
+// eval (BIN (LIT "(") (BIN e (LIT ")"))) = eval e
+// eval (INT i) = Just i
+// eval (LIT _) = Nothing
+// eval (BIN l (OPT Nothing)) = eval l
+// eval (BIN l (OPT (Just a))) = eval (BIN l a)
+// //Right associative operators
+// eval (BIN l (BIN (LIT op) r)) = op2op op <*> eval l <*> eval r
+// //Left associative operators
+// eval (BIN l (MANY [])) = eval l
+// eval (BIN l (MANY [BIN (LIT op) r:rest]))
+// = eval (BIN (BIN l (BIN (LIT op) r)) (MANY rest))
+// eval e = abort ("eval: " +++ printToString e +++ "\n")
+//
+// print :: Gast -> String
+// print (BIN (LIT "(") (BIN e (LIT ")"))) = "(" +++ print e +++ ")"
+// print (INT i) = toString i
+// print (LIT l) = l
+// print (BIN l (OPT Nothing)) = print l
+// print (BIN l (OPT (Just a))) = print (BIN l a)
+// //Right associative operators
+// print (BIN l (BIN (LIT op) r)) = "(" +++ print l +++ op +++ print r +++ ")"
+// //Left associative operators
+// print (BIN l (MANY [])) = print l
+// print (BIN l (MANY [BIN (LIT op) r:rest]))
+// = print (BIN (BIN l (BIN (LIT op) r)) (MANY rest))
+// print e = printToString e +++ "\n"
+//
+// op2op "+" = Just (+)
+// op2op "-" = Just (-)
+// op2op "*" = Just (*)
+// op2op "/" = Just (/)
+// op2op "%" = Just (rem)
+// op2op "^" = Just (^)
+// op2op _ = Nothing
+//
+//import Text.GenPrint
+//derive gPrint Gast, Maybe