A value decides wether the given input string should be accepted or not and converts it into Elm object when accepted.

Parse the given string and return the result. It returns Just value when the string is accepted, Nothing otherwise.

parse "abc" (match "abc") == Just "abc"
parse "xyz" (match "abc") == Nothing

This Parser alway succeeds on parse and results in the given argument without consumption. Typically used with andThen.

This Parser always fails on parse. It is "mzero" on monad context. Typically used with andThen.

Generate the parser accepts the specified string. The parser returns the same string when accepts.

parse "abc" (match "abc") == Just "abc"
parse "xyz" (match "abc") == Nothing

Generate the parser accepts characters satisfied with the specified predicator. The parser returns the specified character when accepted.

char Char.isUpper |> parse "A"  == Just 'A'
char Char.isUpper |> parse "a"  == Nothing

Generate the parser accepts consecutive characters satisfied with the specified predicator. The parser returns the string when accepted.

char Char.isUpper |> parse "AAA"  == Just "AAA"
char Char.isUpper |> parse "aaa"  == Nothing

Concatenate two specified parsers, in other words, generate new parser accepts the sequence. The result is also merged according to the 3rd parameter.

seq2 (match "con") (match "cat") (++) |> parse "concat" == Just "concat"

Generate new parser from specified parsers. result parser accepts all inputs specified parsers accept. This combinator is ordered, in other words, if the first parser accepts input, the second parser is ignored. These parsers needs to be '() -> Parser' form. (It is useful for avoiding infinite reference.)

p =
    choice
    [ \() -> match "foo"
    , \() -> match "bar"
    ]
p |> parse "foo" == Just "foo"
p |> parse "bar" == Just "bar"

Generate optional parser. It accepts whatever string and consumes only if specified parser accepts. The parse result is Maybe value.

option (match "foo") |> parse "" == Just Nothing

Generate zero-or-more parser. It accept zero or more consecutive repetitions of string specified parser accepts. it always behaves greedily, consuming as much input as possible.

p = zeroOrMore (match "a")
p |> parse "aaa" == Just ["a", "a", "a"]
p |> parse "" == Just []

Generate one-or-more parser. It accept one or more consecutive repetitions of string specified parser accepts. it always behaves greedily, consuming as much input as possible.

p = oneOrMore (match "a")
p |> parse "aaa" == Just ["a", "a", "a"]
p |> parse "" == Nothing

Generate and-predicate parser. The parse succeeds if the specified parser accepts the input and fails if the specified parser rejects, but in either case, never consumes any input.

word = chars (always True)
p = seq2 (andPredicate (match "A")) (\_ w -> w)
p |> parse "Apple" == Just "Apple"
p |> parse "Banana" == Nothing

Generate not-predicate parser. The parse succeeds if the specified parser rejects the input and fails if the specified parser accepts, but in either case, never consumes any input.

nums = chars Char.isDigit
p = seq2 (notPredicate (match "0")) nums (\_ i -> i)
p |> parse "1234" == Just "1234"
p |> parse "0123" == Nothing

Generate new parser return mapped result by specifying mapper.

Incorporate specified parser to the parser. It re-parse the input using specified parser with the original result when the original parser success parse, otherwise the parse failed. Using it can set more stringent conditions for parse success.

intParser =
  chars Char.isDigit
    |> andThen (\str ->
      case String.toInt str of
        Just i -> return i
        Nothing -> fail)

Concatenate two parsers with a specified parser in between.

ws = match " " |> oneOrMore
varTy = choise [ \() -> match "int", \() -> match "char" ]
varName = chars Char.isAlpha
varDecl =
  intersperseSeq2
  ws varTy varName           -- matches like "int x" or "char  foo"
  (\ty name -> ( ty, name )) -- result like ("int", "x") or ("char", "foo")

Generate one-or-more parser with a specified parser in between.

chars Char.isAlpha
  |> join (match ", ")
  |> parse "foo, bar, baz" -- == ["foo", "bar", "baz"]