\begin{code}
module Parser (parse) where

import Syntax (Type(..))
import Lexer (identifier, reservedOp, parens, brackets)

import Text.Parsec hiding (parse)
import qualified Text.Parsec (parse)
import Text.Parsec.String

parse :: String -> Type
parse s =  let parser = do  spaces
                            t <- typeParser
                            spaces
                            eof
                            return t
           in case Text.Parsec.parse parser "" s of Right sigma -> sigma

typeParser :: Parser Type
typeParser = choice  [  try $ do  s <- basicTypeParser
                                  _ <- reservedOp "->"
                                  t <- typeParser
                                  return (s `To` t)
                     ,  basicTypeParser]

basicTypeParser :: Parser Type
basicTypeParser = choice  [  try $ do  i <- identifier
                                       case i of 
                                         "Maybe"  -> fmap Maybe atomicTypeParser
                                         _        -> parserZero
                          ,  atomicTypeParser]

atomicTypeParser :: Parser Type
atomicTypeParser = choice  [  do   i <- identifier
                                   case i of 
                                     "a"      -> return Alpha
                                     "alpha"  -> return Alpha
                                     "Bool"   -> return Bool
                                     "Int"    -> return Int
                                     _        -> parserZero
                           ,  fmap List (brackets typeParser)
                           ,  parens typeParser]
\end{code}