Haskell token parsing helper http://hackage.haskell.org/package/parsec/docs/Text-Parsec-Token.html

Parse.hs

module Parse
  ( lexeme
  , identifier
  , reserved
  , operator
  , reservedOp
  , charLiteral
  , stringLiteral
  , symbol
  , whiteSpace
  , natural
  , integer
  , float
  , naturalOrFloat
  , decimal
  , hexadecimal
  , octal
  , parens
  , braces
  , angles
  , brackets
  , semi
  , semiSep
  , semiSep1
  , colon
  , comma
  , commaSep
  , commaSep1
  , dot
  ) where

import           Text.Parsec
import           Text.Parsec.String (Parser)
import qualified Text.Parsec.Token  as P

languageDef :: P.LanguageDef a
languageDef
  = P.LanguageDef
      { commentStart    = "{-"
      , commentEnd      = "-}"
      , commentLine     = "--"
      , nestedComments  = False
      , identStart      = letter
      , identLetter     = alphaNum <|> char '_'
      , opStart         = oneOf ":!#$%&*+./<=>?@\\^|-~"
      , opLetter        = oneOf ":!#$%&*+./<=>?@\\^|-~"
      , reservedNames   = ["λ"]
      , reservedOpNames = [":", ".", "@"]
      , caseSensitive   = True
      }

lexer :: P.TokenParser a
lexer = P.makeTokenParser languageDef

-- parse as lexeme (skipping trailing ws)
lexeme :: Parser a -> Parser a
lexeme = P.lexeme lexer

-- valid identifier
identifier :: Parser String
identifier = P.identifier lexer

-- reserved identifier
reserved :: String -> Parser ()
reserved = P.reserved lexer

-- valid operator
operator :: Parser String
operator = P.operator lexer

reservedOp :: String -> Parser ()
reservedOp = P.reservedOp lexer

-- haskell char literal
charLiteral :: Parser Char
charLiteral = P.charLiteral lexer

-- haskell string literal
stringLiteral :: Parser String
stringLiteral = P.stringLiteral lexer

-- any symbol (like string s <* spaces)
symbol :: String -> Parser String
symbol = P.symbol lexer

whiteSpace :: Parser ()
whiteSpace = P.whiteSpace lexer

natural :: Parser Integer
natural = P.natural lexer

-- natural with leading sign (+/-)
integer :: Parser Integer
integer = P.integer lexer

float :: Parser Double
float = P.float lexer

naturalOrFloat :: Parser (Either Integer Double)
naturalOrFloat = P.naturalOrFloat lexer

decimal :: Parser Integer
decimal = P.decimal lexer

hexadecimal :: Parser Integer
hexadecimal = P.hexadecimal lexer

octal :: Parser Integer
octal = P.octal lexer

-- parse stuff inside parens/braces/angle brackets/square brackets
parens :: Parser a -> Parser a
parens = P.parens lexer

braces :: Parser a -> Parser a
braces = P.braces lexer

angles :: Parser a -> Parser a
angles = P.angles lexer

brackets :: Parser a -> Parser a
brackets = P.brackets lexer

-- actual ; char
semi :: Parser String
semi = P.semi lexer

-- ; separated `a`s
semiSep :: Parser a -> Parser [a]
semiSep = P.semiSep lexer

semiSep1 :: Parser a -> Parser [a]
semiSep1 = P.semiSep lexer

-- actual : char
colon :: Parser String
colon = P.colon lexer

-- actual , char
comma :: Parser String
comma = P.comma lexer

-- , separated `a`s
commaSep :: Parser a -> Parser [a]
commaSep = P.commaSep lexer

commaSep1 :: Parser a -> Parser [a]
commaSep1 = P.commaSep1 lexer

-- actual . char
dot :: Parser String
dot = P.dot lexer