The mpc Reference Manual

This is the mpc Reference Manual, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Feb 26 17:23:27 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 mpc

Monadic Parser Combinators for Common Lisp. MPC tries to be simple and practical while being powerful, well documented and fairly performant. A friendly fork of Drew Crampsies _Smug_ library.

Author

Max Rottenkolber <>

License

GNU Affero General Public License

Source

mpc.asd.

Child Components

3 Files

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


3.1 Lisp


3.1.1 mpc/mpc.asd

Source

mpc.asd.

Parent Component

mpc (system).

ASDF Systems

mpc.


3.1.2 mpc/packages.lisp

Source

mpc.asd.

Parent Component

mpc (system).

Packages

3.1.3 mpc/input.lisp

Dependency

packages.lisp (file).

Source

mpc.asd.

Parent Component

mpc (system).

Internals

3.1.4 mpc/mpc.lisp

Dependencies
Source

mpc.asd.

Parent Component

mpc (system).

Public Interface
Internals

3.1.5 mpc/characters.lisp

Dependencies
Source

mpc.asd.

Parent Component

mpc (system).

Public Interface

3.1.6 mpc/numerals.lisp

Dependencies
Source

mpc.asd.

Parent Component

mpc (system).

Public Interface

3.1.7 mpc/error.lisp

Dependencies
Source

mpc.asd.

Parent Component

mpc (system).

Public Interface
Internals

4 Packages

Packages are listed by definition order.


4.1 mpc.characters

This package includes parsers specialised for character input. Covered are case sensitivity, strings, whitespace and lines.

Source

packages.lisp.

Use List
  • common-lisp.
  • mpc.
Used By List

mpc.numerals.

Public Interface

4.2 mpc

Monadic parser combinators. This package contains general purpose parser combinators of varying sophistication. It also contains the {run} entry function and a handful of macros that integrate parser combinators into the Common Lisp condition system. Functions starting with the {=}-prefix construct _parsers_. Their documentation is written from the perspective of the resulting parser. Refer to the [MPC Manual](manual.html) for a general introduction.

Source

packages.lisp.

Use List

common-lisp.

Used By List
Public Interface
Internals

4.3 mpc.numerals

This package includes parsers for string numerals.
Covered are single digits, natural numbers and signed integers with arbitrary radixes.

Source

packages.lisp.

Use List
Public Interface

5 Definitions

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


5.1 Public Interface


5.1.1 Special variables

Special Variable: *whitespace*

*Value Type:*

a _list_ of _characters_.

*Description:*

The _value_ of {*whitespace*} is a _list_ of _characters_ considered to be _whitespace characters_.

Package

mpc.characters.

Source

characters.lisp.


5.1.2 Macros

Macro: =fail (&body handling)

*Arguments and Values:*

_handling_—_forms_ to run when the parser is invoked.

*Description:*

{=fail} always fails. If supplied, the _handling forms_ will be run when {=fail} is applied. The _handling forms_ may call {get-input-position}.

Package

mpc.

Source

mpc.lisp.

Macro: =handler-case (parser &rest handlers)

*Arguments and Values:*

_parser_—a _parser_.

_handlers_—handler clauses for {handler-case}.

*Description:*

{=handler-case} establishes _handlers_ as if by {handler-case} before applying _parser_ to the input. _Handlers_ must return _parsers_. If _parser_ signals an _error_ matched by a _handler_, the _parser_ returned by the _handler_ will be applied to the input.

Package

mpc.

Source

error.lisp.

Macro: =let* (bindings &body forms)

_bindings_::= {(}{{}{(}_symbol_ _parser_{)}{\}}\*{)}

*Arguments and Values:*

_forms_—_forms_ of which the last _form_ must return a _parser_.

_symbol_—a _symbol_.

_parser_—a _form_ whose result is a _parser_.

*Description:*

{=let*} applies the _parsers_ in _bindings_ as if by {=and} and evaluates _forms_ in an implicit {let} environment where the results are bound to the _symbols_ in _bindings_. Finally, {=let*} applies the parser returned by the last _form_.

Package

mpc.

Source

mpc.lisp.

Macro: =restart-case (parser &rest restarts)

*Arguments and Values:*

_parser_—a _parser_.

_restarts_—restart clauses for {restart-case}.

*Description:*

{=restart-case} establishes _restarts_ as if by {restart-case} before applying _parser_ to the input. _Restarts_ must return _parsers_. If _parser_ signals an _error_ matched by a _restart_, the _parser_ returned by the _restart_ will be applied to the input.

Package

mpc.

Source

error.lisp.


5.1.3 Ordinary functions

Function: =and (&rest parsers)

*Arguments and Values:*

_parsers_—_parsers_.

*Description:*

{=and} applies _parsers_ sequentially. If all _parsers_ succeed, {=and} succeeds with the last _parser_’s result. Otherwise {=and} fails.

Package

mpc.

Source

mpc.lisp.

Function: =at-least (n parser &key limit)

*Arguments and Values:*

_n_, _limit_—_bounding index designators_. The default for _limit_ is {nil}.

_parser_—a _parser_.

*Description:*

{=at-least} applies _parser_ repeatedly until it fails and succeeds with a list of the results unless _parser_ succeeded less than _n_ times or, if _limit_ is not {nil}, more than _limit_ times.

Package

mpc.

Source

mpc.lisp.

Function: =bind (parser make-parser)

*Arguments and Values:*

_parser_—a _parser_.

_make-parser_—a _function designator_ for a one-argument _function_ which returns a _parser_.

*Description:*

{=bind} applies _parser_ to the input. For each resulting {(value . input)} pair {=bind} calls _make-parser_ with each _value_ and applies the resulting parser to each _input_. {=bind} succeeds with the concatenated results or fails if _parser_ fails.

Package

mpc.

Source

mpc.lisp.

Function: =character (character &optional case-sensitive-p)

*Arguments and Values:*

_character_—a _character_.

_case-sensitive-p_—a _generalized boolean_. The default is _true_.

*Description:*

{=character} consumes the next item and succeeds with that item as its result if the item is equal to _character_. {=character} is case sensitive unless _case-sensitive-p_ is _false_.

Package

mpc.characters.

Source

characters.lisp.

Function: =digit (&optional radix)

*Arguments and Values:*

_radix_—a _number_ of _type_ {(integer 2 36)}. The default is {10}.

*Description:*

{=digit} consumes the next item and succeeds with that item as its result if the next item is a digit _character_ in the specified _radix_.

Package

mpc.numerals.

Source

numerals.lisp.

Function: =end-of-input ()

*Description:*

{=end-of-input} succeeds only if the input is empty.

Package

mpc.

Source

mpc.lisp.

Function: =eql (x)

*Arguments and Values:*

_x_—an _object_.

*Description:*

{=eql} consumes the next item and succeeds with that item as its result if the item is {eql} to _object_.

Package

mpc.

Source

mpc.lisp.

Function: =exactly (n parser)

*Arguments and Values:*

_n_—an non-negative _integer_.

_parser_—a _parser_.

*Description:*

{=exactly} applies _parser_ repeatedly until it fails and succeeds with a list of the results unless _parser_ succeeded not exactly _n_ times.

Package

mpc.

Source

mpc.lisp.

Function: =funcall (parser function)

*Arguments and Values:*

_parser_—a _parser_.

_function_—a _function designator_.

*Description:*

{=funcall} applies _parser_. If successful, {=funcall} applies _function_ on its result and succeeds with the return value.

Package

mpc.

Source

mpc.lisp.

Function: =if (test-parser then-parser &optional else-parser)

*Arguments and Values:*

_test-parser_—a _parser_.

_then-parser_—a _parser_.

_else-parser_—a _parser_. The default is {(=fail)}.

*Description:*

{=if} applies _then-parser_ if _test-parser_ would succeed and _else-parser_ otherwise. Note that _test-parser_ is not actually applied to the input.

Package

mpc.

Source

mpc.lisp.

Function: =integer-number (&optional radix)

*Arguments and Values:*

_radix_—a _number_ of _type_ {(integer 2 36)}. The default is {10}.

*Description:*

{=integer-number} consumes a signed non-empty sequence of digit _characters_ in the specified _radix_ and succeeds with the _integer_ represented by that sequence. The leading sign is optional and can be {#\\+} and {#\\-} for positive and negative values
respectively. The default is a positive value.

Package

mpc.numerals.

Source

numerals.lisp.

Function: =item ()

*Description:*

{=item} consumes the next item and succeeds with that item as its result unless the input is empty.

Package

mpc.

Source

mpc.lisp.

Function: =line (&optional keep-newline-p)

*Arguments and Values:*

_keep-newline-p_—a _generalized boolean_. The default is _false_.

*Description:*

{=line} consumes a sequence of zero or more _characters_ terminated by a {#\\Newline} _character_ and succeeds with the _characters_ coerced to a _string_. The terminating {#\\Newline} _character_ is not included in the result unless _keep-newline-p_ is _true_.

Package

mpc.characters.

Source

characters.lisp.

Function: =list (&rest parsers)

*Arguments and Values:*

_parsers_—_parsers_.

*Description:*

{=list} applies _parsers_ sequentially. If all _parsers_ succeed, {=list} succeeds with a list of their results. Otherwise {=list} fails.

Package

mpc.

Source

mpc.lisp.

Function: =maybe (parser)

*Arguments and Values:*

_parser_—a _parser_.

*Description:*

{=maybe} applies _parser_. If _parser_ succeeds {=maybe} will succeed with its result, otherwise it will succeed with {nil}.

Package

mpc.

Source

mpc.lisp.

Function: =natural-number (&optional radix)

*Arguments and Values:*

_radix_—a _number_ of _type_ {(integer 2 36)}. The default is {10}.

*Description:*

{=natural-number} consumes a non-empty sequence of digit _characters_ in the specified _radix_ and succeeds with the natural _number_ represented by that sequence.

Package

mpc.numerals.

Source

numerals.lisp.

Function: =newline ()

*Description:*

{=newline} consumes the next item and succeeds with that item as its result if the item is the {#\\Newline} _character_.

Package

mpc.characters.

Source

characters.lisp.

Function: =none-of (list)

*Arguments and Values:*

_list_—a _list_ of _objects_.

*Description:*

{=none-of} consumes the next item and succeeds with that item as its result unless the item is {eql} to one of the _objects_ in _list_.

Package

mpc.

Source

mpc.lisp.

Function: =not (parser)

*Arguments and Values:*

_parser_—a _parser_.

*Description:*

{=not} consumes the next item and succeeds with that item as its result if _parser_ would fail. E.g. it negates _parser_. Note that _parser_ is not actually applied to the input.

Package

mpc.

Source

mpc.lisp.

Function: =one-of (list)

*Arguments and Values:*

_list_—a _list_ of _objects_.

*Description:*

{=one-of} consumes the next item and succeeds with that item as its result if the item is {eql} to any _object_ in _list_.

Package

mpc.

Source

mpc.lisp.

Function: =one-or-more (parser)

*Arguments and Values:*

_parser_—a _parser_.

*Description:*

{=one-or-more} applies _parser_ repeatedly until it fails and succeeds with a list of the results if _parser_ succeeded at least one time.

Package

mpc.

Source

mpc.lisp.

Function: =one-to (n parser)

*Arguments and Values:*

_n_—a positive _integer_.

_parser_—a _parser_.

*Description:*

{=one-to} applies _parser_ repeatedly until it fails and succeeds with a list of the results unless _parser_ succeeded less than once or more than _n_ times.

Package

mpc.

Source

mpc.lisp.

Function: =or (&rest parsers)

*Arguments and Values:*

_parsers_—_parsers_.

*Description:*

{=or} applies _parsers_ until one _parser_ succeeds, in which case it succeeds with the result of that _parser_. If no _parser_ succeeds {=or} fails.

Package

mpc.

Source

mpc.lisp.

Function: =plus (&rest parsers)

*Arguments and Values:*

_parser_—a _parser_.

*Description:*

{=plus} is the non-deterministic choice combinator. It applies _parsers_ to input and succeeds with the result of every successful _parser_. {=plus} fails if every _parser_ fails.

Package

mpc.

Source

mpc.lisp.

Function: =prog1 (parser &rest parsers)

*Arguments and Values:*

_parser_—a _parser_.

_parsers_—_parsers_.

*Description:*

{=prog1} applies _parser_ and _parsers_ sequentially. If they all succeed, {=prog1} succeeds with _parser_’s result. Otherwise {=prog1} fails.

Package

mpc.

Source

mpc.lisp.

Function: =prog2 (parser1 parser2 &rest parsers)

*Arguments and Values:*

_parser1_—a _parser_.

_parser2_—a _parser_.

_parsers_—_parsers_.

*Description:*

{=prog2} applies _parser1_, _parser2_ and _parsers_ sequentially. If they all succeed, {=prog2} succeeds with _parser2_’s result. Otherwise {=prog2} fails.

Package

mpc.

Source

mpc.lisp.

Function: =range (from to &key parser predicate)

*Arguments and Values:*

_from_—an _object_.

_to_—an _object_.

_parser_—a _parser_. The default is {(=item)}.

_predicate_—a _function designator_ for a three-argument predicate _function_. The default is {char<=}.

*Description:*

{=range} applies _parser_ and, if it succeeds, applies _predicate_ to _from_, its results and _to_. {=range} succeeds with the result of _parser_ if _predicate_ is _true_ and fails otherwise.

Package

mpc.

Source

mpc.lisp.

Function: =result (value)

*Arguments and Values:*

_value_—an _object_.

*Description:*

{=result} always succeeds with _value_ as its result.

Package

mpc.

Source

mpc.lisp.

Function: =satisfies (predicate)

*Arguments and Values:*

_predicate_—a _function designator_ for a one-argument predicate _function_.

*Description:*

{=satisfies} consumes the next item and succeeds with that item as its result if the result satisfies _predicate_.

Package

mpc.

Source

mpc.lisp.

Function: =skip-whitespace (parser)

*Arguments and Values:*

_parser_—a _parser_.

*Description:*

{=skip-whitespace} consumes a sequence of zero or more items which are members of {*whitespace*} and then applies _parser_ and, if successful, succeeds with its result.

Package

mpc.characters.

Source

characters.lisp.

Function: =string (string &optional case-sensitive-p)

*Arguments and Values:*

_string_—a _string_.

_case-sensitive-p_—a _generalized boolean_. The default is _true_.

*Description:*

{=string} consumes a non-empty sequence of _characters_ and succeeds with the _character sequence_ coerced to a _string_ if the result is equal to _sting_. {=string} is case sensitive unless _case-sensitive-p_ is _false_.

Package

mpc.characters.

Source

characters.lisp.

Function: =string-of (parser)

*Arguments and Values:*

_parser_—a _parser_.

*Description:*

{=string-of} repeatedly applies _parser_ to the input and succeeds with the resulting _character sequence_ coerced to a _string_. {=string-of} fails unless _parser_ succeeds at least once.

Package

mpc.characters.

Source

characters.lisp.

Function: =unless (test-parser &rest parsers)

*Arguments and Values:*

_test-parser_—a _parser_.

_parsers_—_parsers_.

*Description:*

{=unless} applies _parsers_ as if by {=and} if _test-parser_ would fail. Note that _test-parser_ is not actually applied to the input.

Package

mpc.

Source

mpc.lisp.

Function: =when (test-parser &rest parsers)

*Arguments and Values:*

_test-parser_—a _parser_.

_parsers_—_parsers_.

*Description:*

{=when} applies _parsers_ as if by {=and} if _test-parser_ would succeed. Note that _test-parser_ is not actually applied to the input.

Package

mpc.

Source

mpc.lisp.

Function: =whitespace ()

*Description:*

{=whitespace} consumes the next item and succeeds with that item as its result if the item is a member of {*whitespace*}.

Package

mpc.characters.

Source

characters.lisp.

Function: =zero-or-more (parser)

*Arguments and Values:*

_parser_—a _parser_.

*Description:*

{=zero-or-more} applies _parser_ repeatedly until it fails and succeeds with a list of the results.

Package

mpc.

Source

mpc.lisp.

Function: =zero-to (n parser)

*Arguments and Values:*

_n_—an non-negative _integer_.

_parser_—a _parser_.

*Description:*

{=zero-to} applies _parser_ repeatedly until it fails and succeeds with a list of the results unless _parser_ succeeded more than _n_ times.

Package

mpc.

Source

mpc.lisp.

Function: get-input-position ()

→ _position_

→ _position_, _line_, _column_

*Arguments and Values:*

_position_, _column_—non-negative _integers_.

_line_—a positive _integer_.

*Description:*

{get-input-position} returns the number of items read from the input. Additionally, _line_ and _column_ positions are returned if the input’s _element type_ is {character}. Lines are counted starting at 1 while columns are counted starting from 0.

{get-input-position} may only be called from within the body of {=fail}, the handlers of {=handler-case} or the restarts of {=restart-case}.

*Exceptional Situations:*

{get-input-position} signals an _error_ of _type_ {simple-error} unless called within {=fail}, {=handler-case} or {=restart-case}.

Package

mpc.

Source

error.lisp.

Function: run (parser input-source &key result)

*Arguments and Values:*

_parser_—a _parser_.

_input-source_—an _array_, an _input stream_ or a _list_.

_result_—a _function designator_ to a one-argument _function_. The default is {caar}.

*Description:*

{run} applies _parser_ to _input-source_ and returns the result of calling the _result_ function on the resulting list of
{(value . input)} pairs.

Package

mpc.

Source

mpc.lisp.


5.2 Internals


5.2.1 Special variables

Special Variable: *input-at-run*

Bound to initial input during RUN.

Package

mpc.

Source

mpc.lisp.

Special Variable: *input-during-fail*

Bound to input during =FAIL.

Package

mpc.

Source

mpc.lisp.


5.2.2 Ordinary functions

Function: =binary-and (parser-a parser-b)

=BIND PARSER-A and PARSER-B and fail if any of those fails. Otherwise return the result of PARSER-B.

Package

mpc.

Source

mpc.lisp.

Function: cases-to-parser-cases (cases input)

Utility macro function for =HANDLER-CASE and =RESTART-CASE.

Package

mpc.

Source

error.lisp.

Function: copy-index (instance)
Package

mpc.

Source

input.lisp.

Function: copy-index-array (instance)
Package

mpc.

Source

input.lisp.

Function: copy-index-list (instance)
Package

mpc.

Source

input.lisp.

Function: copy-index-simple-array (instance)
Package

mpc.

Source

input.lisp.

Function: copy-index-simple-string (instance)
Package

mpc.

Source

input.lisp.

Reader: index-array-array (instance)
Package

mpc.

Source

input.lisp.

Target Slot

array.

Function: index-array-p (object)
Package

mpc.

Source

input.lisp.

Function: index-array-position (instance)
Package

mpc.

Source

input.lisp.

Reader: index-list-list (instance)
Package

mpc.

Source

input.lisp.

Target Slot

list.

Function: index-list-p (object)
Package

mpc.

Source

input.lisp.

Function: index-list-position (instance)
Package

mpc.

Source

input.lisp.

Function: index-p (object)
Package

mpc.

Source

input.lisp.

Reader: index-position (instance)
Package

mpc.

Source

input.lisp.

Target Slot

position.

Function: index-simple-array-array (instance)
Package

mpc.

Source

input.lisp.

Function: index-simple-array-p (object)
Package

mpc.

Source

input.lisp.

Function: index-simple-array-position (instance)
Package

mpc.

Source

input.lisp.

Function: index-simple-string-array (instance)
Package

mpc.

Source

input.lisp.

Function: index-simple-string-p (object)
Package

mpc.

Source

input.lisp.

Function: index-simple-string-position (instance)
Package

mpc.

Source

input.lisp.

Function: make-index (&key position)
Package

mpc.

Source

input.lisp.

Function: make-index-array (&key position array)
Package

mpc.

Source

input.lisp.

Function: make-index-list (&key position list)
Package

mpc.

Source

input.lisp.

Function: make-index-simple-array (&key position array)
Package

mpc.

Source

input.lisp.

Function: make-index-simple-string (&key position array)
Package

mpc.

Source

input.lisp.

Function: parse-line-position (input position)

Parses line position of POSITION in INPUT.

Package

mpc.

Source

error.lisp.


5.2.3 Generic functions

Generic Function: input-element-type (input)

Returns element type of {INPUT}.

Package

mpc.

Source

input.lisp.

Methods
Method: input-element-type ((input index-array))
Method: input-element-type (input)
Generic Function: input-empty-p (input)

Predicate to test if {INPUT} is empty.

Package

mpc.

Source

input.lisp.

Methods
Method: input-empty-p ((input index-array))
Method: input-empty-p ((input index-list))
Generic Function: input-first (input)

Returns first element of {INPUT}.

Package

mpc.

Source

input.lisp.

Methods
Method: input-first ((input index-simple-string))
Method: input-first ((input index-simple-array))
Method: input-first ((input index-array))
Method: input-first ((input index-list))
Generic Function: input-position (input)

Returns index position of {INPUT}.

Package

mpc.

Source

input.lisp.

Methods
Method: input-position ((input index))
Generic Function: input-rest (input)

Returns {INPUT} with its first element stripped.

Package

mpc.

Source

input.lisp.

Methods
Method: input-rest ((input index-simple-string))
Method: input-rest ((input index-simple-array))
Method: input-rest ((input index-array))
Method: input-rest ((input index-list))
Generic Function: make-input (source)

Returns input object for {SOURCE}.

Package

mpc.

Source

input.lisp.

Methods
Method: make-input ((input file-stream))
Method: make-input ((input string))
Method: make-input ((input array))
Method: make-input ((input list))

5.2.4 Structures

Structure: index

Generic index.

Package

mpc.

Source

input.lisp.

Direct superclasses

structure-object.

Direct subclasses
Direct methods

input-position.

Direct slots
Slot: position
Package

common-lisp.

Type

mpc::array-index

Initform

0

Readers

index-position.

Writers

This slot is read-only.

Structure: index-array

Index array.

Package

mpc.

Source

input.lisp.

Direct superclasses

index.

Direct subclasses
Direct methods
Direct slots
Slot: array
Package

common-lisp.

Type

array

Initform

(error "must supply array.")

Readers

index-array-array.

Writers

This slot is read-only.

Structure: index-list

Index list.

Package

mpc.

Source

input.lisp.

Direct superclasses

index.

Direct methods
Direct slots
Slot: list
Package

common-lisp.

Type

list

Initform

(error "must supply list.")

Readers

index-list-list.

Writers

This slot is read-only.

Structure: index-simple-array

Index simple array.

Package

mpc.

Source

input.lisp.

Direct superclasses

index-array.

Direct methods
Structure: index-simple-string

Index simple string.

Package

mpc.

Source

input.lisp.

Direct superclasses

index-array.

Direct methods

5.2.5 Types

Type: array-index ()

Array index type used in index structure.

Package

mpc.

Source

input.lisp.


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   =  
C   F   G   I   M   P   R  
Index Entry  Section

=
=and: Public ordinary functions
=at-least: Public ordinary functions
=binary-and: Private ordinary functions
=bind: Public ordinary functions
=character: Public ordinary functions
=digit: Public ordinary functions
=end-of-input: Public ordinary functions
=eql: Public ordinary functions
=exactly: Public ordinary functions
=fail: Public macros
=funcall: Public ordinary functions
=handler-case: Public macros
=if: Public ordinary functions
=integer-number: Public ordinary functions
=item: Public ordinary functions
=let*: Public macros
=line: Public ordinary functions
=list: Public ordinary functions
=maybe: Public ordinary functions
=natural-number: Public ordinary functions
=newline: Public ordinary functions
=none-of: Public ordinary functions
=not: Public ordinary functions
=one-of: Public ordinary functions
=one-or-more: Public ordinary functions
=one-to: Public ordinary functions
=or: Public ordinary functions
=plus: Public ordinary functions
=prog1: Public ordinary functions
=prog2: Public ordinary functions
=range: Public ordinary functions
=restart-case: Public macros
=result: Public ordinary functions
=satisfies: Public ordinary functions
=skip-whitespace: Public ordinary functions
=string: Public ordinary functions
=string-of: Public ordinary functions
=unless: Public ordinary functions
=when: Public ordinary functions
=whitespace: Public ordinary functions
=zero-or-more: Public ordinary functions
=zero-to: Public ordinary functions

C
cases-to-parser-cases: Private ordinary functions
copy-index: Private ordinary functions
copy-index-array: Private ordinary functions
copy-index-list: Private ordinary functions
copy-index-simple-array: Private ordinary functions
copy-index-simple-string: Private ordinary functions

F
Function, =and: Public ordinary functions
Function, =at-least: Public ordinary functions
Function, =binary-and: Private ordinary functions
Function, =bind: Public ordinary functions
Function, =character: Public ordinary functions
Function, =digit: Public ordinary functions
Function, =end-of-input: Public ordinary functions
Function, =eql: Public ordinary functions
Function, =exactly: Public ordinary functions
Function, =funcall: Public ordinary functions
Function, =if: Public ordinary functions
Function, =integer-number: Public ordinary functions
Function, =item: Public ordinary functions
Function, =line: Public ordinary functions
Function, =list: Public ordinary functions
Function, =maybe: Public ordinary functions
Function, =natural-number: Public ordinary functions
Function, =newline: Public ordinary functions
Function, =none-of: Public ordinary functions
Function, =not: Public ordinary functions
Function, =one-of: Public ordinary functions
Function, =one-or-more: Public ordinary functions
Function, =one-to: Public ordinary functions
Function, =or: Public ordinary functions
Function, =plus: Public ordinary functions
Function, =prog1: Public ordinary functions
Function, =prog2: Public ordinary functions
Function, =range: Public ordinary functions
Function, =result: Public ordinary functions
Function, =satisfies: Public ordinary functions
Function, =skip-whitespace: Public ordinary functions
Function, =string: Public ordinary functions
Function, =string-of: Public ordinary functions
Function, =unless: Public ordinary functions
Function, =when: Public ordinary functions
Function, =whitespace: Public ordinary functions
Function, =zero-or-more: Public ordinary functions
Function, =zero-to: Public ordinary functions
Function, cases-to-parser-cases: Private ordinary functions
Function, copy-index: Private ordinary functions
Function, copy-index-array: Private ordinary functions
Function, copy-index-list: Private ordinary functions
Function, copy-index-simple-array: Private ordinary functions
Function, copy-index-simple-string: Private ordinary functions
Function, get-input-position: Public ordinary functions
Function, index-array-array: Private ordinary functions
Function, index-array-p: Private ordinary functions
Function, index-array-position: Private ordinary functions
Function, index-list-list: Private ordinary functions
Function, index-list-p: Private ordinary functions
Function, index-list-position: Private ordinary functions
Function, index-p: Private ordinary functions
Function, index-position: Private ordinary functions
Function, index-simple-array-array: Private ordinary functions
Function, index-simple-array-p: Private ordinary functions
Function, index-simple-array-position: Private ordinary functions
Function, index-simple-string-array: Private ordinary functions
Function, index-simple-string-p: Private ordinary functions
Function, index-simple-string-position: Private ordinary functions
Function, make-index: Private ordinary functions
Function, make-index-array: Private ordinary functions
Function, make-index-list: Private ordinary functions
Function, make-index-simple-array: Private ordinary functions
Function, make-index-simple-string: Private ordinary functions
Function, parse-line-position: Private ordinary functions
Function, run: Public ordinary functions

G
Generic Function, input-element-type: Private generic functions
Generic Function, input-empty-p: Private generic functions
Generic Function, input-first: Private generic functions
Generic Function, input-position: Private generic functions
Generic Function, input-rest: Private generic functions
Generic Function, make-input: Private generic functions
get-input-position: Public ordinary functions

I
index-array-array: Private ordinary functions
index-array-p: Private ordinary functions
index-array-position: Private ordinary functions
index-list-list: Private ordinary functions
index-list-p: Private ordinary functions
index-list-position: Private ordinary functions
index-p: Private ordinary functions
index-position: Private ordinary functions
index-simple-array-array: Private ordinary functions
index-simple-array-p: Private ordinary functions
index-simple-array-position: Private ordinary functions
index-simple-string-array: Private ordinary functions
index-simple-string-p: Private ordinary functions
index-simple-string-position: Private ordinary functions
input-element-type: Private generic functions
input-element-type: Private generic functions
input-element-type: Private generic functions
input-empty-p: Private generic functions
input-empty-p: Private generic functions
input-empty-p: Private generic functions
input-first: Private generic functions
input-first: Private generic functions
input-first: Private generic functions
input-first: Private generic functions
input-first: Private generic functions
input-position: Private generic functions
input-position: Private generic functions
input-rest: Private generic functions
input-rest: Private generic functions
input-rest: Private generic functions
input-rest: Private generic functions
input-rest: Private generic functions

M
Macro, =fail: Public macros
Macro, =handler-case: Public macros
Macro, =let*: Public macros
Macro, =restart-case: Public macros
make-index: Private ordinary functions
make-index-array: Private ordinary functions
make-index-list: Private ordinary functions
make-index-simple-array: Private ordinary functions
make-index-simple-string: Private ordinary functions
make-input: Private generic functions
make-input: Private generic functions
make-input: Private generic functions
make-input: Private generic functions
make-input: Private generic functions
Method, input-element-type: Private generic functions
Method, input-element-type: Private generic functions
Method, input-empty-p: Private generic functions
Method, input-empty-p: Private generic functions
Method, input-first: Private generic functions
Method, input-first: Private generic functions
Method, input-first: Private generic functions
Method, input-first: Private generic functions
Method, input-position: Private generic functions
Method, input-rest: Private generic functions
Method, input-rest: Private generic functions
Method, input-rest: Private generic functions
Method, input-rest: Private generic functions
Method, make-input: Private generic functions
Method, make-input: Private generic functions
Method, make-input: Private generic functions
Method, make-input: Private generic functions

P
parse-line-position: Private ordinary functions

R
run: Public ordinary functions


A.4 Data types

Jump to:   A   C   E   F   I   M   N   P   S   T  
Index Entry  Section

A
array-index: Private types

C
characters.lisp: The mpc/characters․lisp file

E
error.lisp: The mpc/error․lisp file

F
File, characters.lisp: The mpc/characters․lisp file
File, error.lisp: The mpc/error․lisp file
File, input.lisp: The mpc/input․lisp file
File, mpc.asd: The mpc/mpc․asd file
File, mpc.lisp: The mpc/mpc․lisp file
File, numerals.lisp: The mpc/numerals․lisp file
File, packages.lisp: The mpc/packages․lisp file

I
index: Private structures
index-array: Private structures
index-list: Private structures
index-simple-array: Private structures
index-simple-string: Private structures
input.lisp: The mpc/input․lisp file

M
mpc: The mpc system
mpc: The mpc package
mpc.asd: The mpc/mpc․asd file
mpc.characters: The mpc․characters package
mpc.lisp: The mpc/mpc․lisp file
mpc.numerals: The mpc․numerals package

N
numerals.lisp: The mpc/numerals․lisp file

P
Package, mpc: The mpc package
Package, mpc.characters: The mpc․characters package
Package, mpc.numerals: The mpc․numerals package
packages.lisp: The mpc/packages․lisp file

S
Structure, index: Private structures
Structure, index-array: Private structures
Structure, index-list: Private structures
Structure, index-simple-array: Private structures
Structure, index-simple-string: Private structures
System, mpc: The mpc system

T
Type, array-index: Private types