tur/parsec

0, the null pointer representing no results.

  (mzero)  ; => 0

A newly allocated Cell containing x with a null next pointer.

  (mreturn 42)  ; => Cell{value=42, next=NULL}

A new Cell list containing all results from xs followed by ys.

  (mplus (mreturn 1) (mreturn 2))  ; => Cell{1} -> Cell{2}

The concatenated results of applying fn to every value in ma,
  preserving original order.

  (mbind (mreturn 1) (fn [x] (mreturn (* x 2))))  ; => Cell{2}

0 (null pointer).

A new Cell with value v pointing to nxt.

  (bt-cons 3 (bt-nil))  ; => Cell{3, NULL}

The number of cells in the list as an int64_t.

  (bt-length (bt-cons 1 (bt-cons 2 (bt-nil))))  ; => 2

Pointer (as int64_t) to a heap-allocated Pair{first=a, second=b}.

  (pair-new 1 2)  ; => Pair{first=1, second=2}

The int64_t value stored in the first field.

  (pair-first (pair-new 7 8))  ; => 7

The int64_t value stored in the second field.

  (pair-second (pair-new 7 8))  ; => 8

Pointer (as int64_t) to a heap-allocated Input{str, pos}.

  (input-new "hello" 0)  ; => Input at position 0

true if the current character is '\0', false otherwise.

  (input-at-end (input-new "" 0))  ; => true

The ASCII code of the current character as an int64_t (unsigned byte).

  (input-current-char (input-new "abc" 0))  ; => 97  ; 'a'

A new heap-allocated Input with pos incremented by 1.

  (input-pos (input-advance (input-new "ab" 0)))  ; => 1

The int64_t character offset into the source string.

  (input-pos (input-new "abc" 2))  ; => 2

The number of bytes from the current position to the terminating '\0'.

  (input-remaining (input-new "abc" 1))  ; => 2

The int64_t return value of the closure.

  (apply-fat my-fn 42)  ; => result of calling my-fn with 42

A Cell list of Pair(value, remaining-Input) results.

  (apply-parser (item) (input-new "a" 0))  ; => Cell{Pair(97, Input@1)}

A parser that returns mzero for any input.

  (run-parser (pfail) "abc")  ; => 0  (no results)

A parser that returns Pair(v, inp) without advancing the input.

  (run-parser (pure 99) "")  ; => Cell{Pair(99, Input@0)}

A parser yielding the ASCII code of the next character, or
  failure if at end of input.

  (parse-value (run-parser (item) "A"))  ; => 65  ; 'A'

A parser that succeeds with c if the next character equals c,
  or fails otherwise.

  (parse-value (run-parser (pchar 65) "ABC"))  ; => 65  ; 'A'

The raw pointer value of s as an int64_t.

A parser that succeeds with s (as int64_t pointer) and advances
  past it, or fails if the input does not start with s.

  (run-parser (pstring "hi") "hi there")  ; => Cell{Pair("hi", Input@2)}

A parser that returns the concatenation of results from p and q
  applied to the same input (full backtracking).

  (run-parser (or-parser (pchar 65) (pchar 66)) "B")  ; => Cell{Pair(66, ...)}

A parser that runs p, then for each result calls (f value) and runs
  the resulting parser on the remaining input.

  (bind-parser (item) (fn [c] (pure c)))  ; identity parser

A parser that runs p, then runs q on the remaining input,
  returning only q's results.

  (run-parser (then-parser (pchar 40) (item)) "(x")
  ; => Cell{Pair(120, Input@2)}  ; 'x' only

A parser that always succeeds, yielding a Cell list of all
  matched values and the remaining Input after the last match.
  Returns an empty list when p does not match at all.

  (run-parser (many (pchar 97)) "aab")
  ; => Cell{Pair(Cell{97,97}, Input@2)}

A parser that succeeds only when p matches at least once, then
  greedily repeats, returning results identical in structure to many.

  (run-parser (many1 (pchar 97)) "aab")
  ; => Cell{Pair(Cell{97,97}, Input@2)}
  (run-parser (many1 (pchar 97)) "bbb")  ; => 0  (fails)

A parser that returns two results when p succeeds (the match and
  a fallback with value 0), or one result with value 0 when p fails.
  Check pair-first: 0 means absent, non-zero means the parsed value.

  (run-parser (optional (pchar 65)) "ABC")  ; => two results
  (run-parser (optional (pchar 65)) "XYZ")  ; => Cell{Pair(0, Input@0)}

A Cell list of Pair(value, remaining-Input) for all successful
  parses, including partial ones.

  (run-parser (pchar 65) "ABC")  ; => Cell{Pair(65, Input@1)}

A Cell wrapping the parsed value if the entire input was consumed,
  or 0 (mzero) if no full parse exists.

  (run-parser-full (many (pchar 97)) "aaa")
  ; => Cell{value=Cell{97,97,97}}
  (run-parser-full (pchar 97) "ab")  ; => 0  (leftover input)

The int64_t value from pair-first of the first Cell, or 0 if empty.

  (parse-value (run-parser (pchar 65) "A"))  ; => 65

The number of successful parse results as an int64_t.

  (parse-result-count (run-parser (or-parser (pchar 65) (pchar 65)) "A"))
  ; => 2  (both branches succeed)

(print-char-list (bt-cons 65 (bt-cons 66 (bt-nil))))
  ; prints: 65 66

The number of elements as an int64_t.

  (char-list-length (bt-cons 1 (bt-cons 2 (bt-nil))))  ; => 2