add missing files

Author: gdevanla

src/Text/Parsec/String/Char.hs

@@ -0,0 +1,63 @@
+module Text.Parsec.String.Char where
+
+{-
+
+Wrappers for the Text.Parsec.Char module with the types fixed to
+'Text.Parsec.String.Parser a', i.e. the stream is String, no user
+state, Identity monad.
+
+-}
+
+import qualified Text.Parsec.Char as C
+import Text.Parsec.String (Parser)
+
+spaces :: Parser ()
+spaces = C.spaces
+
+space :: Parser Char
+space = C.space
+
+newline :: Parser Char
+newline = C.newline
+
+tab :: Parser Char
+tab = C.tab
+
+upper :: Parser Char
+upper = C.upper
+
+lower :: Parser Char
+lower = C.lower
+
+alphaNum :: Parser Char
+alphaNum = C.alphaNum
+
+letter :: Parser Char
+letter = C.letter
+
+digit :: Parser Char
+digit = C.digit
+
+hexDigit :: Parser Char
+hexDigit = C.hexDigit
+
+octDigit :: Parser Char
+octDigit = C.octDigit
+
+char :: Char -> Parser Char
+char = C.char
+
+string :: String -> Parser String
+string = C.string
+
+anyChar :: Parser Char
+anyChar = C.anyChar
+
+oneOf :: [Char] -> Parser Char
+oneOf = C.oneOf
+
+noneOf :: [Char] -> Parser Char
+noneOf = C.noneOf
+
+satisfy :: (Char -> Bool) -> Parser Char
+satisfy = C.satisfy

src/Text/Parsec/String/Combinator.hs

@@ -0,0 +1,84 @@
+
+module Text.Parsec.String.Combinator where
+
+{-
+
+Wrappers for the Text.Parsec.Combinator module with the types fixed to
+'Text.Parsec.String.Parser a', i.e. the stream is String, no user
+state, Identity monad.
+
+-}
+
+import qualified Text.Parsec.Combinator as C
+import Text.Parsec.String (Parser)
+
+choice :: [Parser a] -> Parser a
+choice = C.choice
+
+
+count :: Int -> Parser a -> Parser [a]
+count = C.count
+
+between :: Parser open -> Parser close -> Parser a -> Parser a
+between = C.between
+
+
+option :: a -> Parser a -> Parser a
+option = C.option
+
+optionMaybe :: Parser a -> Parser (Maybe a)
+optionMaybe = C.optionMaybe
+
+optional :: Parser a -> Parser ()
+optional = C.optional
+
+skipMany1 :: Parser a -> Parser ()
+skipMany1 = C.skipMany1
+
+many1 :: Parser a -> Parser [a]
+many1 = C.many1
+
+sepBy :: Parser a -> Parser sep -> Parser [a]
+sepBy = C.sepBy
+
+sepBy1 :: Parser a -> Parser sep -> Parser [a]
+sepBy1 = C.sepBy1
+
+endBy :: Parser a -> Parser sep -> Parser [a]
+endBy = C.endBy
+
+endBy1 :: Parser a -> Parser sep -> Parser [a]
+endBy1 = C.endBy1
+
+sepEndBy :: Parser a -> Parser sep -> Parser [a]
+sepEndBy = C.sepEndBy
+
+sepEndBy1 :: Parser a -> Parser sep -> Parser [a]
+sepEndBy1 = C.sepEndBy1
+
+chainl :: Parser a -> Parser (a -> a -> a) -> a -> Parser a
+chainl = C.chainl
+
+chainl1 :: Parser a -> Parser (a -> a -> a) -> Parser a
+chainl1 = C.chainl1
+
+chainr :: Parser a -> Parser (a -> a -> a) -> a -> Parser a
+chainr = C.chainr
+
+chainr1 :: Parser a -> Parser (a -> a -> a) -> Parser a
+chainr1 = C.chainr1
+
+eof :: Parser ()
+eof = C.eof
+
+notFollowedBy :: Show a => Parser a -> Parser ()
+notFollowedBy = C.notFollowedBy
+
+manyTill :: Parser a -> Parser end -> Parser [a]
+manyTill = C.manyTill
+
+lookAhead :: Parser a -> Parser a
+lookAhead = C.lookAhead
+
+anyToken :: Parser Char
+anyToken = C.anyToken

src/Text/Parsec/String/Expr.hs

@@ -0,0 +1,30 @@
+
+module Text.Parsec.String.Expr (buildExpressionParser
+                               ,Operator(..)
+                               ,OperatorTable
+                               ,E.Assoc(..)
+                               )where
+
+{-
+
+Wrappers for the Text.Parsec.Expr module with simplified types.
+
+-}
+
+import Text.Parsec.String (Parser)
+import qualified Text.Parsec.Expr as E
+
+-- not sure if this is neccessary, or a type alias would be good
+-- enough
+data Operator a = Infix (Parser (a -> a -> a)) E.Assoc
+                | Prefix (Parser (a -> a))
+                | Postfix (Parser (a -> a))
+
+type OperatorTable a = [[Operator a]]
+
+buildExpressionParser :: OperatorTable a -> Parser a -> Parser a
+buildExpressionParser t = E.buildExpressionParser (map (map f) t)
+  where
+    f (Infix p a) = E.Infix p a
+    f (Prefix p) = E.Prefix p
+    f (Postfix p) = E.Postfix p

src/Text/Parsec/String/Parsec.hs

@@ -0,0 +1,18 @@
+
+module Text.Parsec.String.Parsec where
+
+{-
+
+wrapper for some Text.Parsec functions which use a simplified type
+
+-}
+
+import Text.Parsec.String (Parser)
+import qualified Text.Parsec as P
+
+
+try :: Parser a -> Parser a
+try = P.try
+
+parse :: Parser a -> P.SourceName -> String -> Either P.ParseError a
+parse = P.parse