Add Text.Parsing.Parser.Language and Token modules.

bower.json

@@ -29,7 +29,9 @@
     "purescript-lists": "^0.7.0",
     "purescript-maybe": "^0.3.0",
     "purescript-strings": "~0.7.0",
-    "purescript-transformers": "^0.8.1"
+    "purescript-transformers": "^0.8.1",
+    "purescript-unicode": "git://github.com/purescript-contrib/purescript-unicode#unicode",
+    "purescript-integers": "^0.2.0"
   },
   "devDependencies": {
     "purescript-console": "^0.1.0",

src/Text/Parsing/Parser/Combinators.purs

@@ -38,6 +38,10 @@ import Text.Parsing.Parser
 (<?>) :: forall m s a. (Monad m) => ParserT s m a -> String -> ParserT s m a
 (<?>) p msg = p <|> fail ("Expected " ++ msg)
 
+-- | Flipped `(<?>)`.
+(<??>) :: forall m s a. (Monad m) => String -> ParserT s m a -> ParserT s m a
+(<??>) = flip (<?>)
+
 -- | Wrap a parser with opening and closing markers.
 -- |
 -- | For example:
@@ -196,4 +200,3 @@ many1Till p end = do
   x <- p
   xs <- manyTill p end
   return (x:xs)
-

src/Text/Parsing/Parser/Language.purs

@@ -0,0 +1,125 @@
+
+module Text.Parsing.Parser.Language
+    -- ( haskellDef, haskell
+    -- , mondrianDef, mondrian
+    -- , emptyDef
+    -- , haskellStyle
+    -- , javaStyle
+    -- )
+      where
+
+import Prelude
+
+import Control.Alt
+
+import Text.Parsing.Parser
+import Text.Parsing.Parser.String
+import Text.Parsing.Parser.Token
+
+-----------------------------------------------------------
+-- Styles: haskellStyle, javaStyle
+-----------------------------------------------------------
+
+-- | This is a minimal token definition for Haskell style languages. It
+-- defines the style of comments, valid identifiers and case
+-- sensitivity. It does not define any reserved words or operators.
+
+haskellStyle :: LanguageDef
+haskellStyle = LanguageDef (unGenLanguageDef emptyDef)
+                { commentStart    = "{-"
+                , commentEnd      = "-}"
+                , commentLine     = "--"
+                , nestedComments  = true
+                , identStart      = letter
+                , identLetter     = alphaNum <|> oneOf ['_', '\'']
+                , opStart         = op'
+                , opLetter        = op'
+                , reservedOpNames = []
+                , reservedNames   = []
+                , caseSensitive   = true
+                }
+  where
+    op' :: forall m . (Monad m) => ParserT String m Char
+    op' = oneOf [':', '!', '#', '$', '%', '&', '*', '+', '.', '/', '<', '=', '>', '?', '@', '\\', '^', '|', '-', '~']
+
+-- | This is a minimal token definition for Java style languages. It
+-- defines the style of comments, valid identifiers and case
+-- sensitivity. It does not define any reserved words or operators.
+
+javaStyle  :: LanguageDef
+javaStyle   = LanguageDef (unGenLanguageDef emptyDef)
+                { commentStart    = "/*"
+                , commentEnd      = "*/"
+                , commentLine     = "//"
+                , nestedComments  = true
+                , identStart      = letter
+                , identLetter     = alphaNum <|> oneOf ['_', '\'']
+                , reservedNames   = []
+                , reservedOpNames = []
+                , caseSensitive   = false
+                }
+
+-----------------------------------------------------------
+-- minimal language definition
+--------------------------------------------------------
+
+-- | This is the most minimal token definition. It is recommended to use
+-- this definition as the basis for other definitions. `emptyDef` has
+-- no reserved names or operators, is case sensitive and doesn't accept
+-- comments, identifiers or operators.
+
+emptyDef :: LanguageDef
+emptyDef = LanguageDef
+            { commentStart:    ""
+            , commentEnd:      ""
+            , commentLine:     ""
+            , nestedComments:  true
+            , identStart:      letter <|> char '_'
+            , identLetter:     alphaNum <|> oneOf ['_', '\'']
+            , opStart:         op'
+            , opLetter:        op'
+            , reservedOpNames: []
+            , reservedNames:   []
+            , caseSensitive:   true
+            }
+  where
+    op' :: forall m . (Monad m) => ParserT String m Char
+    op' = oneOf [':', '!', '#', '$', '%', '&', '*', '+', '.', '/', '<', '=', '>', '?', '@', '\\', '^', '|', '-', '~']
+
+-- -----------------------------------------------------------
+-- -- Haskell
+-- -----------------------------------------------------------
+
+-- -- | A lexer for the haskell language.
+
+haskell :: TokenParser
+haskell = makeTokenParser haskellDef
+
+-- -- | The language definition for the Haskell language.
+
+haskellDef  :: LanguageDef
+haskellDef   =
+    case haskell98Def of
+        (LanguageDef def) -> LanguageDef def
+                { identLetter    = def.identLetter <|> char '#'
+                , reservedNames  = def.reservedNames <>
+                                   ["foreign","import","export","primitive"
+                                   ,"_ccall_","_casm_"
+                                   ,"forall"
+                                   ]
+                }
+
+-- -- | The language definition for the language Haskell98.
+
+haskell98Def :: LanguageDef
+haskell98Def = LanguageDef (unGenLanguageDef haskellStyle)
+                { reservedOpNames = ["::","..","=","\\","|","<-","->","@","~","=>"]
+                , reservedNames   = [ "let","in","case","of","if","then","else"
+                                    , "data","type"
+                                    , "class","default","deriving","do","import"
+                                    , "infix","infixl","infixr","instance","module"
+                                    , "newtype","where"
+                                    , "primitive"
+                                    -- "as","qualified","hiding"
+                                    ]
+                }