{-# NoImplicitPrelude #-}

module DataConstuctorParser where

import Prelude
import Control.Monad
import Control.Monad.State
import Control.Applicative
import Data.Char
import Data.Functor
import System.IO
import Data.List

data DataConstructor = DataConstructor String [String] deriving Show

parseCapital = oneOf "ABCDEFGHIGKLMNOPQRSTUVWXYZ"

parseDownCharString = many $ oneOf "abcdefghijklmnopqrstuvwxyz"

parseConstructorName = do
  x <- parseCapital
  y <- parseDownCharString
  z <- many $ lexem $ parseDownCharString
  return $ DataConstructor (x:y) z

parseCons str = runStateT parseConstructorName str


type Apar a = StateT String Maybe a

isempty s foo = if (s == []) then Nothing else foo

parseByPred foo = StateT $ \s -> isempty s $ if (foo $ head s)
                                           then Just (head s, tail s)
                                           else Nothing
char c = parseByPred (== c)

spaces = many $ char ' '

oneOf str = parseByPred (`elem` str)

lexem p = do
  x <- p
  spaces
  return x

between f p g = do
  f
  x <- p
  g
  return x

exactly 0 _ = return []
exactly n p = (:) <$> p <*> exactly (n - 1) p

manySepBy p g = (:) <$> p <*> many (g >> p)

parseInt = (many $ lexem $ oneOf "0xABCDEF1234567890") >>= \x -> if x == [] then mzero else return (read x :: Int)
-----------------------------------