The parsnip Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The parsnip Reference Manual

This is the parsnip Reference Manual, version 0.0.7, generated automatically by Declt version 3.0 "Montgomery Scott" on Sun May 15 05:46:22 2022 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

Parsnip

builds.sr.ht status

The library brand image: a crudely drawn parsnip surrounded by parentheses

Monadic parser combinator library.

Conventional parsers are modeled as a two-stage process: a scanner that takes characters and produce tokens, and a parser that takes tokens and produce syntax trees. Monadic parsers instead model parsers as smaller parsers that can compose together, much like the procedures of a conventional program.

Other parser combinator libraries I've found for Common Lisp are either too macro-heavy for me, or warn that they are not production-ready. I don't trust third-party libraries that don't trust themselves, and so I've made my own, going for a simple interface targeted for public consumption.

Parsnip targets user-facing compilers, interpreters, or other readers of character-based languages, where programs would like to recover from or give insight about parser errors. Parsnip does not target performance-intensive or byte-based decoders, such as those used in network stacks, or JSON/XML decoders for request data for high-performance web applications.

Contributions

Any comments, questions, issues, or patches are greatly appreciated! I do my main development on Sourcehut, with a mailing list and issue tracker.

Usage

Parsnip is available on Quicklisp:

(ql:quickload :parsnip)

Parsnip can also be installed locally. Make sure to also install the sole dependency Alexandria:

$ cd ~/common-lisp/ # Or wherever you store your definitions
$ git clone https://git.sr.ht/~shunter/parsnip
(require :parsnip)
(use-package :parsnip)

;; digit := [0-9]
(defparser one-digit ()
  (char-if #'digit-char-p))

(defparser digits ()
  (collect1 'one-digit))

;; whole-part := digit+
(defparser whole-part ()
  (let! ((digits 'digits))
    (ok (parse-integer (coerce digits 'string)))))

;; decimal-part := '.' [0-9]+
(defparser decimal-part ()
  (let! ((digits (progn! (char-of #\.) 'digits)))
    (ok (/ (parse-integer (coerce digits 'string))
           (expt 10 (length digits))))))

;; number := whole-part [ decimal-part ]
(defparser decimal-number ()
  (let! ((whole-value 'whole-part)
         (decimal-value (or! 'decimal-part (ok 0))))
    (ok (+ whole-value decimal-value))))

(defun parse-from-string (parser string)
  (with-input-from-string (stream string)
    (parse parser stream)))

(parse-from-string 'decimal-number "123.47") ;; => 12347/100

Parsnip aims to provide rich information for parsers aimed at end-users:

(use-package :xyz.shunter.parsnip.examples.json)

;; bad.json: [10,20,,]
(with-open-file (s "/tmp/bad.json")
  (decode-json s))
/tmp/bad.json:1:7: Expected (#\f #\n #\t #\{ #\[
                             (:integer . 10) #\") on #<STREAM>
[Condition of type PARSER-ERROR]

(with-open-file (s "/tmp/bad.json")
  (handler-case (decode-json s)
    (parser-error (c)
      (values (parser-error-line c)
              (parser-error-column c)))))
=> 1
   7

(handler-case (decode-json-from-string "[10,20,{\"foo\":\"bar\",}]")
  (parser-error (c)
    (format t "~A~%" c)
    (parser-error-return-trace c)))
NIL:1:20: Expected #\" on #<STRING-INPUT-STREAM>
((xyz.shunter.parsnip.examples.json::value 1 0)
 (xyz.shunter.parsnip.examples.json::json-array 1 0)
 (xyz.shunter.parsnip.examples.json::value 1 7)
 (xyz.shunter.parsnip.examples.json::json-object 1 7)
 (xyz.shunter.parsnip.examples.json::json-string 1 20))

The test suite shows how each function works, and how it's expected to perform.

Is this Production-ready?

After a couple months of working on this project in my spare time, I believe it is ready for public use. However, you may have certain requirements for your own project which would hold you off from using this library over something else:

Breaking Changes

When the library reaches 1.0, I need to consider what parts of the library to solidify. I recognize these as breaking changes:

I recognize these as non-breaking changes:

Examples

The JSON example matches close to the grammar notation of the RFC8259 JSON specification. Outside of a couple outliers (e.g. the value definition is moved to the end), the code is laid out nearly section-by-section as stated in the RFC.

The Tiny C example is an extremely bare-bones subset of C, with a single primitive integer type and limited mechanisms. It demonstrates an example of what patterns can be used to parse C-family grammars with parser combinators.

Concepts

Parsers are given four "tracks" of continuations: success/failure with consumed input, and "empty" success/failure (that is, without consumed output). Most combinators that handle failures, only handle empty failures. The two exceptions are handle-rewind and try!, which saves the input stream's position and rewinds to an "empty" state before handling the failure. A consumed success only matters to retrack all future empty continuations to consumed continuations (so a consumed success followed by an empty failure counts as a consumed failure).

This model is used by Haskell's parsec and megaparsec libraries. I tried to use a simple ok/fail model, but after writing the example JSON and Tiny C files, found that this model works best.

API

[Function] ok value => parser

Return a parser that consumes nothing and returns the given value:

(with-input-from-string (s "abc123")
  (list (parse (ok :hello) s)
        (alexandria:read-stream-content-into-string)))

=> (:hello "abc123")

[Function] fail expected &optional trace => parser

Return a parser that consumes nothing and fails, reporting the expected value.

[Function] char-if predicate &optional message => char-parser

Return a parser that consumes a character that satisfies the given predicate.

[Function] char-of char &optional message => char-parser

Return a parser that consumes the given character.

[Function] char-in charbag &optional message => char-parser

Return a parser that consumes a character in the given character bag.

[Function] string-of string &optional message => string-parser

Return a parser that consumes the given simple string. This parser may have consumed input on a failure.

[Function] eof &optional value => parser

Return a parser that consumes nothing and returns the given value (or nil) if the input stream is exhausted.

[Function] flatmap function parser => parser

Return a new parser that applies the given function to the parser's result, and then runs the parser the function returns. This function forms the basis of stringing multiple parsers together.

[Macro] let! (&rest bindings) &body body => parser

Return a parser that runs all given parsers, binds them all to their variables, evaluates the body, and then runs the parser the body returns.

[Function] handle parser handler => parser

Return a new parser that, on failure, applies the handler function to the parser's expected value and parse trace (as a list), and then runs the parser the handler returns.

handle does not handle partial-parse failures, which can be recovered from via handle-rewind.

[Function] handle-rewind parser handler => parser

Return a new parser that saves the stream's current position and, on failure, rewinds the stream, applies the handler function to the parser's expected value and parse trace (as a list), and then runs the parser the handler returns.

handle-rewind only works when the parser is given a seekable stream.

[Function] try! parser => parser

Return a new parser that saves the stream's current position and, on failure, rewinds the stream before passing the failure down.

try! only works when the parser is given a seekable stream.

[Function] progn! &rest parsers => parser

Return a parser that strings together all given parsers and returns the last parser's result.

[Function] prog1! first &rest parsers => parser

Return a parser that strings together all given parsers and returns the first parser's result.

[Function] prog2! first second &rest parsers => parser

Return a parser that strings together all given parsers and returns the second parser's result.

[Function] or! &rest parsers => parser

Return a parser that tries each given parser in order (until a partial-parse failure) and returns the result of the first successful parse.

If all parsers fail, then the parser error accumulates a list of all possible expected values.

[Function] collect parser => list-parser

Return a parser that runs the given parser until failure, and collects all results into a list.

[Function] collect1 parser => list-parser

Return a parser that runs the given parser once, keeps parsing until failure, and then collects all results into a list.

[Function] collect-into-string char-parser => string-parser

Return a parser that runs the given character parser until failure, and collects all characters into a string.

[Function] sep value-parser sep-parser => value-list-parser

Return a parser that accepts a sequence of value-parser input separated by sep-parser input; such as values separated by commas.

[Function] reduce! function parser &key initial-parser => parser

Return a parser that keeps running until failure, and reduces its result into one value.

If initial-parser is supplied, the parser may succeed without calling FUNCTION by returning INITIAL-PARSER's response.

[Function] skip parser => parser

Parse and pretend no input was consumed.

[Function] skip-many parser => parser

Keep parsing until failure, discard the results, and pretend no input was consumed.

[Function] digit &optional (radix 10) => integer-parser

Consume and return the number value of a digit.

[Function] natural &optional (radix 10) => integer-parser

Consume and return a natural number.

[Macro] defparser name () &body (form) => symbol

Define a parser as a function. It can then be referenced as a function designator.

[Function] parse parser stream => object

Run a parser through a given stream and raise any failures as a parser-error.

[Condition] parser-error (stream-error)

Parser errors are raised by parse when a parser cannot recover from an error. Parser error readers provide the line and column a parser ended at, the return-trace of defparser-defined parsers and the lines and columns each parser started at, and an object that describes what the parser expected:

A return-trace is a list of (parser-name line column)-structured objects detailing the state of the composite parser when it failed.

For both the parser-error and return-trace, lines start at 1 and columns start at 0, and is initialized per parse call.


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 parsnip

Author

Samuel Hunter

Contact

~shunter/public-inbox@lists.sr.ht

Home Page

https://sr.ht/~shunter/parsnip/

Source Control

(:git "https://git.sr.ht/~shunter/parsnip")

Bug Tracker

https://todo.sr.ht/~shunter/parsnip

License

BSD 3-Clause

Description

Parser combinator library

Version

0.0.7

Dependency

alexandria

Source

parsnip.asd (file)

Component

parsnip.lisp (file)


Next: , Previous: , Up: Top   [Contents][Index]

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 parsnip.asd

Location

parsnip.asd

Systems

parsnip (system)


Previous: , Up: Lisp files   [Contents][Index]

3.1.2 parsnip/parsnip.lisp

Parent

parsnip (system)

Location

parsnip.lisp

Packages

xyz.shunter.parsnip

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Previous: , Up: Packages   [Contents][Index]

4.1 xyz.shunter.parsnip

Monadic parser combinator library

Source

parsnip.lisp (file)

Nickname

parsnip

Use List

common-lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Macros

Macro: defparser NAME () &body FORM

Define a parser as a function. It can then be referenced as a function designator.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Macro: let! (&rest BINDINGS) &body BODY

Return ap arser that runs all given parsers, binds them all to their variables, evaluates the body, and then runs the parser the body returns.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.2 Functions

Function: char-if PREDICATE &optional MESSAGE

Return a parser that consumes a character that satisfies the given predicate.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: char-in CHARBAG &optional MESSAGE

Return a parser that consumes a character that’s only in the given charbag.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: char-of CHAR &optional MESSAGE

Return a parser that consumes the given character.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: collect PARSER

Return a parser that runs the given parser until failure, and collects all results into a list.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: collect-into-string CHAR-PARSER

Return a parser that runs the given character parser until failure, and collects all characters into a string.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: collect1 PARSER

Return a parser that runs the given parser once, keeps parsing until failure, and then collects all results into a list.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: digit &optional RADIX

Consume and return the number value of a digit.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: eof &optional VALUE

Return a parser that consumes nothing and returns the given value (or nil) if the input stream is exhausted.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: fail EXPECTED &optional TRACE

Return a parser that consumes nothing and fails, reporting the expected value.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: flatmap FUNCTION PARSER

Return a new parser that applies the given function to the parser’s result, and then runs the parser the function returns. This function forms the basis of stringing multiple parsers together.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: handle PARSER HANDLER

Return a new parser that, on failure, applies the handler function to the parser’s expected value and parse trace (as a list), and then runs the parser the handler returns. HANDLE does not handle partial-parse failures, which can be recovered from via HANDLE-REWIND.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: handle-rewind PARSER HANDLER

Return a new parser that saves the stream’s current position and, on failure, rewinds the stream, applies the handler function to the parser’s expected value and parse trace (as a list), and then runs the parser the handler returns. HANDLE-REWIND only works when the parser is given a seekable stream.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: natural &optional RADIX

Consume and return a natural number.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: ok VALUE

Return a parser that consumes nothing and returns the given value.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: or! &rest PARSERS

Return a parser that tries each given parser in order (until a partial-parse failure) and returns the result of the first successful parse.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: parse PARSER STREAM

Run a parser through a given stream and raise any failures as a PARSER-ERROR.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: prog1! FIRST &rest PARSERS

Return a parser that strings together all given parsers and returns the first parser’s result.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: prog2! FIRST SECOND &rest PARSERS

Return a parser that strings together all given parsers and returns the second parser’s result.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: progn! &rest PARSERS

Return a parser that strings together all given parsers and returns the last parser’s result.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: reduce! FUNCTION PARSER &key INITIAL-PARSER

Return a parser that keeps running until failure, and reduces its results into one value.
If INITIAL-PARSER is supplied, the parser may succeed without calling FUNCTION by returning INITIAL-PARSER’s response.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: sep VALUE-PARSER SEP-PARSER

Return a parser that accepts a sequence of VALUE-PARSER input separated by SEP-PARSER input; such as values separated by commas.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: skip PARSER

Parse and pretend no input was consumed.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: skip-many PARSER

Keep parsing until failure and pretend no input was consumed.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: string-of STRING &optional MESSAGE

Return a parser that consumes the given simple string. This parser may have consumed input on a failure.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: try! PARSER

Return a new parser that saves the stream’s current position and, on failure, rewinds the stream before passing the failure down. TRY! only works when the parser is given a seekable stream.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 Generic functions

Generic Function: parser-error-column CONDITION
Package

xyz.shunter.parsnip

Methods
Method: parser-error-column (CONDITION parser-error)
Source

parsnip.lisp (file)

Generic Function: parser-error-expected CONDITION
Package

xyz.shunter.parsnip

Methods
Method: parser-error-expected (CONDITION parser-error)
Source

parsnip.lisp (file)

Generic Function: parser-error-line CONDITION
Package

xyz.shunter.parsnip

Methods
Method: parser-error-line (CONDITION parser-error)
Source

parsnip.lisp (file)

Generic Function: parser-error-return-trace CONDITION
Package

xyz.shunter.parsnip

Methods
Method: parser-error-return-trace (CONDITION parser-error)
Source

parsnip.lisp (file)


Previous: , Up: Exported definitions   [Contents][Index]

5.1.4 Conditions

Condition: parser-error ()

If a parser fails to read text, it signals a parser-error, containing a stream, its expected value, and a return trace of parsers.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Direct superclasses

stream-error (condition)

Direct methods
Direct slots
Slot: line

The (1-based) line number at which the parser failed

Initargs

:line

Readers

parser-error-line (generic function)

Slot: column

The (0-based) column number at which the parser failed

Initargs

:column

Readers

parser-error-column (generic function)

Slot: expected

An object describing what the parser expected to read

Initargs

:expected

Readers

parser-error-expected (generic function)

Slot: return-trace

A list of (name line column) objects detailing the state of the parser when it failed

Initargs

:return-trace

Readers

parser-error-return-trace (generic function)


Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Macros

Macro: let@ (&rest BINDINGS) &body BODY

Anaphoric self-callable LET.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Functions

Function: advance-pstream PSTREAM C

Update the line and column of PSTREAM given the accepted char C and return PSTREAM.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: consume PSTREAM
Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: parse-stream STREAM
Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: peek PSTREAM
Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: pstream-column INSTANCE
Function: (setf pstream-column) VALUE INSTANCE
Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: pstream-line INSTANCE
Function: (setf pstream-line) VALUE INSTANCE
Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: pstream-stream INSTANCE
Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: rewind PSTREAM SNAPSHOT

Set the (stream) position, line, and column of PSTREAM with the SNAPSHOT received from SAVE.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: save PSTREAM

Return the position, line, and column of PSTREAM.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Function: signal-failure PSTREAM EXPECTED RETURN-TRACE

Signal an error depending on the given fail.

Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Structures

Structure: parse-stream ()
Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: stream
Readers

pstream-stream (function)

Writers

(setf pstream-stream) (function)

Slot: line
Initform

1

Readers

pstream-line (function)

Writers

(setf pstream-line) (function)

Slot: column
Initform

0

Readers

pstream-column (function)

Writers

(setf pstream-column) (function)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.4 Types

Type: function-designator ()
Package

xyz.shunter.parsnip

Source

parsnip.lisp (file)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L   P  
Index Entry  Section

F
File, Lisp, parsnip.asd: The parsnip․asd file
File, Lisp, parsnip/parsnip.lisp: The parsnip/parsnip․lisp file

L
Lisp File, parsnip.asd: The parsnip․asd file
Lisp File, parsnip/parsnip.lisp: The parsnip/parsnip․lisp file

P
parsnip.asd: The parsnip․asd file
parsnip/parsnip.lisp: The parsnip/parsnip․lisp file

Jump to:   F   L   P  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   (  
A   C   D   E   F   G   H   L   M   N   O   P   R   S   T  
Index Entry  Section

(
(setf pstream-column): Internal functions
(setf pstream-line): Internal functions

A
advance-pstream: Internal functions

C
char-if: Exported functions
char-in: Exported functions
char-of: Exported functions
collect: Exported functions
collect-into-string: Exported functions
collect1: Exported functions
consume: Internal functions

D
defparser: Exported macros
digit: Exported functions

E
eof: Exported functions

F
fail: Exported functions
flatmap: Exported functions
Function, (setf pstream-column): Internal functions
Function, (setf pstream-line): Internal functions
Function, advance-pstream: Internal functions
Function, char-if: Exported functions
Function, char-in: Exported functions
Function, char-of: Exported functions
Function, collect: Exported functions
Function, collect-into-string: Exported functions
Function, collect1: Exported functions
Function, consume: Internal functions
Function, digit: Exported functions
Function, eof: Exported functions
Function, fail: Exported functions
Function, flatmap: Exported functions
Function, handle: Exported functions
Function, handle-rewind: Exported functions
Function, natural: Exported functions
Function, ok: Exported functions
Function, or!: Exported functions
Function, parse: Exported functions
Function, parse-stream: Internal functions
Function, peek: Internal functions
Function, prog1!: Exported functions
Function, prog2!: Exported functions
Function, progn!: Exported functions
Function, pstream-column: Internal functions
Function, pstream-line: Internal functions
Function, pstream-stream: Internal functions
Function, reduce!: Exported functions
Function, rewind: Internal functions
Function, save: Internal functions
Function, sep: Exported functions
Function, signal-failure: Internal functions
Function, skip: Exported functions
Function, skip-many: Exported functions
Function, string-of: Exported functions
Function, try!: Exported functions

G
Generic Function, parser-error-column: Exported generic functions
Generic Function, parser-error-expected: Exported generic functions
Generic Function, parser-error-line: Exported generic functions
Generic Function, parser-error-return-trace: Exported generic functions

H
handle: Exported functions
handle-rewind: Exported functions

L
let!: Exported macros
let@: Internal macros

M
Macro, defparser: Exported macros
Macro, let!: Exported macros
Macro, let@: Internal macros
Method, parser-error-column: Exported generic functions
Method, parser-error-expected: Exported generic functions
Method, parser-error-line: Exported generic functions
Method, parser-error-return-trace: Exported generic functions

N
natural: Exported functions

O
ok: Exported functions
or!: Exported functions

P
parse: Exported functions
parse-stream: Internal functions
parser-error-column: Exported generic functions
parser-error-column: Exported generic functions
parser-error-expected: Exported generic functions
parser-error-expected: Exported generic functions
parser-error-line: Exported generic functions
parser-error-line: Exported generic functions
parser-error-return-trace: Exported generic functions
parser-error-return-trace: Exported generic functions
peek: Internal functions
prog1!: Exported functions
prog2!: Exported functions
progn!: Exported functions
pstream-column: Internal functions
pstream-line: Internal functions
pstream-stream: Internal functions

R
reduce!: Exported functions
rewind: Internal functions

S
save: Internal functions
sep: Exported functions
signal-failure: Internal functions
skip: Exported functions
skip-many: Exported functions
string-of: Exported functions

T
try!: Exported functions

Jump to:   (  
A   C   D   E   F   G   H   L   M   N   O   P   R   S   T  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   C   E   L   R   S  
Index Entry  Section

C
column: Exported conditions
column: Internal structures

E
expected: Exported conditions

L
line: Exported conditions
line: Internal structures

R
return-trace: Exported conditions

S
Slot, column: Exported conditions
Slot, column: Internal structures
Slot, expected: Exported conditions
Slot, line: Exported conditions
Slot, line: Internal structures
Slot, return-trace: Exported conditions
Slot, stream: Internal structures
stream: Internal structures

Jump to:   C   E   L   R   S  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   C   F   P   S   T   X  
Index Entry  Section

C
Condition, parser-error: Exported conditions

F
function-designator: Internal types

P
Package, xyz.shunter.parsnip: The xyz․shunter․parsnip package
parse-stream: Internal structures
parser-error: Exported conditions
parsnip: The parsnip system

S
Structure, parse-stream: Internal structures
System, parsnip: The parsnip system

T
Type, function-designator: Internal types

X
xyz.shunter.parsnip: The xyz․shunter․parsnip package

Jump to:   C   F   P   S   T   X