Module

Text.Parsing.Parser.Token

Package
purescript-parsing
Repository
purescript-contrib/purescript-parsing

Functions for working with streams of tokens.

#token Source

token :: forall m a. Monad m => (a -> Position) -> ParserT (List a) m a

Create a parser which Returns the first token in the stream.

#when Source

when :: forall m a. Monad m => (a -> Position) -> (a -> Boolean) -> ParserT (List a) m a

Create a parser which matches any token satisfying the predicate.

#match Source

match :: forall a m. Monad m => Eq a => (a -> Position) -> a -> ParserT (List a) m a

Match the specified token at the head of the stream.

#GenLanguageDef Source

newtype GenLanguageDef s m

The GenLanguageDef type is a record that contains all parameterizable features of the "Text.Parsec.Token" module. The module Text.Parsec.Languager contains some default definitions.

Constructors

#unGenLanguageDef Source

unGenLanguageDef :: forall s m. GenLanguageDef s m -> { caseSensitive :: Boolean, commentEnd :: String, commentLine :: String, commentStart :: String, identLetter :: ParserT s m Char, identStart :: ParserT s m Char, nestedComments :: Boolean, opLetter :: ParserT s m Char, opStart :: ParserT s m Char, reservedNames :: Array String, reservedOpNames :: Array String }

#GenTokenParser Source

type GenTokenParser s m = { angles :: forall a. ParserT s m a -> ParserT s m a, braces :: forall a. ParserT s m a -> ParserT s m a, brackets :: forall a. ParserT s m a -> ParserT s m a, charLiteral :: ParserT s m Char, colon :: ParserT s m String, comma :: ParserT s m String, commaSep :: forall a. ParserT s m a -> ParserT s m (List a), commaSep1 :: forall a. ParserT s m a -> ParserT s m (List a), decimal :: ParserT s m Int, dot :: ParserT s m String, float :: ParserT s m Number, hexadecimal :: ParserT s m Int, identifier :: ParserT s m String, integer :: ParserT s m Int, lexeme :: forall a. ParserT s m a -> ParserT s m a, natural :: ParserT s m Int, naturalOrFloat :: ParserT s m (Either Int Number), octal :: ParserT s m Int, operator :: ParserT s m String, parens :: forall a. ParserT s m a -> ParserT s m a, reserved :: String -> ParserT s m Unit, reservedOp :: String -> ParserT s m Unit, semi :: ParserT s m String, semiSep :: forall a. ParserT s m a -> ParserT s m (List a), semiSep1 :: forall a. ParserT s m a -> ParserT s m (List a), stringLiteral :: ParserT s m String, symbol :: String -> ParserT s m String, whiteSpace :: ParserT s m Unit }

The type of the record that holds lexical parsers that work on s streams over a monad m.

#makeTokenParser Source

makeTokenParser :: forall m. Monad m => GenLanguageDef String m -> GenTokenParser String m

The expression makeTokenParser language creates a GenTokenParser record that contains lexical parsers that are defined using the definitions in the language record.

The use of this function is quite stylized - one imports the appropiate language definition and selects the lexical parsers that are needed from the resulting GenTokenParser.

module Main where

import Text.Parsing.Parser.Language (haskellDef)
import Text.Parsing.Parser.Token (makeTokenParser)

-- The parser
expr = parens expr
   <|> identifier
   <|> ...


-- The lexer
tokenParser = makeTokenParser haskellDef
parens      = tokenParser.parens
braces      = tokenParser.braces
identifier  = tokenParser.identifier
reserved    = tokenParser.reserved
...

#digit Source

digit :: forall m. Monad m => ParserT String m Char

Parse a digit. Matches any char that satisfies Data.Char.Unicode.isDigit.

#hexDigit Source

hexDigit :: forall m. Monad m => ParserT String m Char

Parse a hex digit. Matches any char that satisfies Data.Char.Unicode.isHexDigit.

#octDigit Source

octDigit :: forall m. Monad m => ParserT String m Char

Parse an octal digit. Matches any char that satisfies Data.Char.Unicode.isOctDigit.

#upper Source

upper :: forall m. Monad m => ParserT String m Char

Parse an uppercase letter. Matches any char that satisfies Data.Char.Unicode.isUpper.

#space Source

space :: forall m. Monad m => ParserT String m Char

Parse a space character. Matches any char that satisfies Data.Char.Unicode.isSpace.

#letter Source

letter :: forall m. Monad m => ParserT String m Char

Parse an alphabetical character. Matches any char that satisfies Data.Char.Unicode.isAlpha.

#alphaNum Source

alphaNum :: forall m. Monad m => ParserT String m Char

Parse an alphabetical or numerical character. Matches any char that satisfies Data.Char.Unicode.isAlphaNum.