The readable Reference Manual

Table of Contents

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

The readable Reference Manual

This is the readable Reference Manual, version 1.0.8, generated automatically by Declt version 2.3 "Robert April" on Tue Feb 20 09:17:20 2018 GMT+0.


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

1 Introduction

Readable Lisp S-expressions ("readable")
========================================

This "readable" software improves the readability of Lisp S-expressions
by adding up to three tiers of new s-expression abbreviations.
These tiers are (oversimplified):

1. Curly-infix-expressions (c-expressions): Lists with {...} are infix, in a
   Lispy way: {a op b ...} maps to (op a b ...). No precedence, by intent.
2. Neoteric-expressions (n-expressions): An e(...) maps to
   (e ...), and e{...} with content maps to e({...}).
3. Sweet-expressions (t-expressions): Parentheses are deduced from indentation:
   - An indented line is a parameter of its parent.
   - Later terms on a line are parameters of the first term.
   - A line with exactly one term and no child lines is simply that term.
   - Empty lines end the previous expression. Just type ENTER ENTER
     to execute what you've typed.

Unlike nearly all past efforts to improve s-expression readability, these
are general (the notation is independent from any underlying semantic)
and homoiconic (the underlying data structure is clear from the syntax).
They are also backwards-compatible; nicely-formatted traditional
s-expressions continue work normally.  Thus, it's easy to transition to
these, and you can use traditional forms whenever it's convenient.

Lisp-based languages where this approach or software can be helpful
include Scheme (including guile), Common Lisp, Emacs Lisp, Clojure, Arc,
BitC, ACL2, SUO-KIF, the GCC MiddleEndLispTranslator (MELT),
Satisfiability Modulo Theories Library (SMT-LIB), NewLisp, and ISLisp.
For Scheme these notations are defined in SRFI-105 and SRFI-110.

At this time, the implementation and tools focus on Scheme and Common Lisp,
but some of the tools can be easily used with many other Lisps.

The file "Problem.html" describes the problem this is intended to solve, and
"Solution.html" describes these notations.  Installation instructions
are in "Install-howto.html".  Hands-on tutorials are in
"Scheme-tutorial.html" and "Common-lisp-tutorial.html".  These .html
files are generated from the equivalent .md (markdown) files.

For more information, see:
  http://readable.sourceforge.net


Curly-infix-expression examples
===============================

Here are some examples of basic curly-infix-expressions:

    {3 + 4}             ; (+ 3 4)
    {a * {b + c}}       ; (* a (+ b c))

Neoteric-expression examples
============================

Here are some examples of neoteric expressions
(note that this notation is optional):

    cos(0)              ; (cos 0)
    if({n > max} max n) ; (if (> n max) max n)

Sweet-expression examples
=========================

You can optionally enable sweet-expressions. Remember:
   - An indented line is a parameter of its parent.
   - Later terms on a line are parameters of the first term.
   - A line with exactly one term and no child lines is simply that term.

Here is an example of a sweet-expression:

define fibfast(n)   ; Typical function notation
  if {n < 2}        ; Indentation, infix {...}
     n              ; Single expr = no new list
     fibup n 2 1 0  ; Simple function calls

That sweet-expression would be interpreted as:

(define (fibfast n)
  (if (< n 2)
      n
      (fibup n 2 1 0)))

A sweet-expression reader would accept *either* one.

Here's another example of a sweet-expression and its meaning:

a b c d      ; (a b c d
  e f g      ;    (e f g)
  h i        ;    (h i
    j k l    ;       (j k l)
    m n o    ;       (m n o))
  p          ;    p
  q r s      ;    (q r s))



Maturity
========

This code is *mature* and *production-ready* for Scheme and Common Lisp.
It comes with an extensive test suite, which it passes.


License
=======

With one exception, the software is released under the
"MIT license", which permits practically any use.
The MIT license is an open source software / Free Software
license approved by both the OSI (opensource.org) as an open source software
license, and by the FSF (fsf.org) as a Free software license.
See the COPYING file for the license text.

The one exception is the file "sweet-clisp", which interfaces to clisp.
Most of this file is also licensed under the MIT license.
However, that file contains code derived from the "clisp" program itself.
Clisp is licensed under the "GNU General Public License version 2 (GPLv2)",
so those parts are also under the GPLv2 (see the file for details).
The GPLv2 is also an open source software / Free Software license approved
by both the OSI (opensource.org) as an open source software license,
and by the FSF (fsf.org) as a Free software license.
See the COPYING.GPL file for the conditions for the "sweet-clisp" program.


Getting, building, and installing
=================================

Most people should get the current stable version.  To get the whole package:

* Use your web browser to view http://readable.sourceforge.net
* Click on "Download files"
* Download the current version.

You'll then need to uncompress it.  One way is via the command line:

    tar xvzf readable-*.tar.gz
    cd readable-*

Then follow the installation instructions in the file
"Install-howto.md".  Stable versions also have a file named
"Install-howto.html", which are exactly the same instructions in HTML format
(you can use your web browser!).  The installation instructions are also at:
https://sourceforge.net/p/readable/wiki/Install-howto/

You can also get the development version using "git".
In git the "master" branch contains final released versions, while
the "develop" branch contains the version in development.

This software supports the usual GNU Build System conventions, and
it should be easy to install on most systems.  If you have
very exotic needs, the file INSTALL gives details on how
to precisely control the installation.  For most people the automatic
install will "do the right thing".

Users who only want to use the Common Lisp library can use QuickLisp instead.


Scheme Tutorial
==============

File "Scheme-tutorial.html" is the Scheme tutorial on how to use it.
You need guile to follow it.


Common Lisp Tutorial
====================

File "Common-lisp-tutorial.html" is the Common Lisp tutorial for how to use it.
Any Common Lisp implementation should do, but you need the widely-used system
definition facility ASDF, or use QuickLisp, as described in "Install-howto".
Once installed, you can directly use these notations within your
Common Lisp implementation.


Specification
====================

For Scheme, SRFI-105 (in file "SRFI-105.html") is the official definition of
full curly-infix notation, and it also defines neoteric-expressions.
SRFI-110 (in file "SRFI-110.html" defines sweet-expressions.
SRFI-110 has an especially rigorous BNF.

The file "Solution.md" is the official definition for all other Lisps.
The file "Solution.html" is the same thing in HTML format.
If it's unclear what something means, look at SRFI-105 and SRFI-110
for clarification, but note that the SRFIs include various
Scheme-specific material (e.g., #!sweet is a Scheme-specific mechanism
for enabling sweet-expressions).


Transitioning
=============

The "sweeten" tool is a pretty-printer that translates
s-expressions to sweet-expressions.  You can use "sweeten" to create a file,
hand-tweak the result to make it "prettier", and then use "diff-s-sweet"
to verify that your newly-formatted file has exactly the same meaning.

The "unsweeten" tool can be used as a sweet-expression pre-processor,
so you can use these notations even if your Lisp implementation does not
yet support them.

By default the "sweeten" and "unsweeten" tools process Scheme; if you
have Common Lisp (or something like it), provide the "-C" (Common Lisp)
option as documented.  They can be used as front-ends for other tools.


For more information
===================

For more information, see:
  http://readable.sourceforge.net

Discussions are held on its "readable-discuss" mailing list.



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 readable

Maintainer

David A. Wheeler

Author

David A. Wheeler

License

MIT

Description

Support ’readable’ extensions to Lisp s-expressions

Long Description

Common Lisp implementation of ’readable’ extensions to Lisp s-expresions - curly-infix-expressions, neoteric-expressions, and sweet-expressions, per http://readable.sourceforge.net. This can be useful if you want your Lisp code to be easier to read.

Version

1.0.8

Source

readable.asd (file)

Components

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 readable.asd

Location

readable.asd

Systems

readable (system)

Packages

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

3.1.2 readable/basic-curly.lisp

Parent

readable (system)

Location

basic-curly.lisp

Exported Definitions
Internal Definitions

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

3.1.3 readable/print.lisp

Parent

readable (system)

Location

print.lisp

Exported Definitions
Internal Definitions

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

3.1.4 readable/neoteric.lisp

Dependencies
Parent

readable (system)

Location

neoteric.lisp

Exported Definitions
Internal Definitions

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

3.1.5 readable/backquote.lisp

Parent

readable (system)

Location

backquote.lisp

Internal Definitions

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

3.1.6 readable/sweet.lisp

Dependencies
Parent

readable (system)

Location

sweet.lisp

Exported Definitions
Internal Definitions

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

3.1.7 readable/enablers.lisp

Dependencies
Parent

readable (system)

Location

enablers.lisp

Exported Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 readable

Source

readable.asd

Use List

common-lisp

Exported Definitions
Internal Definitions

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

4.2 readable-asd

Source

readable.asd

Use List

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 Special variables

Special Variable: *noisy*

If true, a parse error prints an error message to standard out

Package

readable

Source

neoteric.lisp (file)

Special Variable: *original-readtable*

Saved readtable

Package

readable

Source

print.lisp (file)

Special Variable: *print-notation*

Currently-active notation used in readable package’s writers

Package

readable

Source

print.lisp (file)

Special Variable: my-char-code-limit
Package

readable

Source

sweet.lisp (file)


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

5.1.2 Macros

Macro: enable-basic-curly ()
Package

readable

Source

enablers.lisp (file)

Macro: enable-curly-infix ()
Package

readable

Source

enablers.lisp (file)

Macro: enable-full-curly-infix ()
Package

readable

Source

enablers.lisp (file)

Macro: enable-neoteric ()
Package

readable

Source

enablers.lisp (file)

Macro: enable-sweet ()
Package

readable

Source

enablers.lisp (file)


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

5.1.3 Functions

Function: basic-curly-read &optional STREAM
Package

readable

Source

basic-curly.lisp (file)

Function: curly-infix-read &optional STREAM
Package

readable

Source

neoteric.lisp (file)

Function: disable-readable ()
Package

readable

Source

basic-curly.lisp (file)

Function: neoteric-read &optional STREAM
Package

readable

Source

neoteric.lisp (file)

Function: output-object-readable OBJECT STREAM
Package

readable

Source

print.lisp (file)

Function: pprint-readable OBJECT &optional STREAM

Prettily output OBJECT preceded by a newline.

Package

readable

Source

print.lisp (file)

Function: prin1-readable OBJECT &optional STREAM

Output a mostly READable printed representation of OBJECT on the specified STREAM.

Package

readable

Source

print.lisp (file)

Function: prin1-to-string-readable OBJECT

Return the printed representation of OBJECT as a string with slashification on.

Package

readable

Source

print.lisp (file)

Function: princ-readable OBJECT &optional STREAM

Output an aesthetic but not necessarily READable printed representation of OBJECT on the specified STREAM.

Package

readable

Source

print.lisp (file)

Function: princ-to-string-readable OBJECT

Return the printed representation of OBJECT as a string with slashification off.

Package

readable

Source

print.lisp (file)

Function: print-readable OBJECT &optional STREAM

Output a newline, the mostly READable printed representation of OBJECT, and space to the specified STREAM.

Package

readable

Source

print.lisp (file)

Function: stringify-object-readable OBJECT
Package

readable

Source

print.lisp (file)

Function: sweet-read &optional STREAM
Package

readable

Source

sweet.lisp (file)

Function: write-readable OBJECT &key (STREAM STREAM) (ESCAPE *PRINT-ESCAPE*) (RADIX *PRINT-RADIX*) (BASE *PRINT-BASE*) (CIRCLE *PRINT-CIRCLE*) (PRETTY *PRINT-PRETTY*) (LEVEL *PRINT-LEVEL*) (LENGTH *PRINT-LENGTH*) (CASE *PRINT-CASE*) (ARRAY *PRINT-ARRAY*) (GENSYM *PRINT-GENSYM*) (READABLY *PRINT-READABLY*) (RIGHT-MARGIN *PRINT-RIGHT-MARGIN*) (MISER-WIDTH *PRINT-MISER-WIDTH*) (LINES *PRINT-LINES*) (PPRINT-DISPATCH *PRINT-PPRINT-DISPATCH*) (SUPPRESS-ERRORS *SUPPRESS-PRINT-ERRORS*) (NOTATION *PRINT-NOTATION*)

Output OBJECT to the specified stream, defaulting to *STANDARD-OUTPUT*.

Package

readable

Source

print.lisp (file)

Function: write-to-string-readable OBJECT &key (ESCAPE *PRINT-ESCAPE*) (RADIX *PRINT-RADIX*) (BASE *PRINT-BASE*) (CIRCLE *PRINT-CIRCLE*) (PRETTY *PRINT-PRETTY*) (LEVEL *PRINT-LEVEL*) (LENGTH *PRINT-LENGTH*) (CASE *PRINT-CASE*) (ARRAY *PRINT-ARRAY*) (GENSYM *PRINT-GENSYM*) (READABLY *PRINT-READABLY*) (RIGHT-MARGIN *PRINT-RIGHT-MARGIN*) (MISER-WIDTH *PRINT-MISER-WIDTH*) (LINES *PRINT-LINES*) (PPRINT-DISPATCH *PRINT-PPRINT-DISPATCH*) (SUPPRESS-ERRORS *SUPPRESS-PRINT-ERRORS*) (NOTATION *PRINT-NOTATION*)

Return the printed representation of OBJECT as a string.

Package

readable

Source

print.lisp (file)


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

5.1.4 Conditions

Condition: readable-parse-error ()
Package

readable

Source

neoteric.lisp (file)

Direct superclasses

parse-error (condition)

Direct methods

text (method)

Direct slots
Slot: text
Initargs

:text

Readers

text (generic function)


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

5.2 Internal definitions


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

5.2.1 Constants

Constant: abbreviations
Package

readable

Source

print.lisp (file)

Constant: boring-length
Package

readable

Source

print.lisp (file)

Constant: datum-commentw-tag
Package

readable

Source

sweet.lisp (file)

Constant: empty-value
Package

readable

Source

sweet.lisp (file)

Constant: form-feed
Package

readable

Source

sweet.lisp (file)

Constant: group-split
Package

readable

Source

sweet.lisp (file)

Constant: group-split-char
Package

readable

Source

sweet.lisp (file)

Constant: hash-pipe-comment-nestsp
Package

readable

Source

sweet.lisp (file)

Constant: initial-comment-eol
Package

readable

Source

sweet.lisp (file)

Constant: line-ending-chars
Package

readable

Source

sweet.lisp (file)

Constant: my-eof-marker
Package

readable

Source

neoteric.lisp (file)

Constant: no-neoteric-value
Package

readable

Source

sweet.lisp (file)

Constant: period-symbol
Package

readable

Source

sweet.lisp (file)

Constant: punct-chars
Package

readable

Source

print.lisp (file)

Constant: scomment-result
Package

readable

Source

sweet.lisp (file)

Constant: special-infix-operators
Package

readable

Source

print.lisp (file)

Constant: sublist
Package

readable

Source

sweet.lisp (file)

Constant: sublist-char
Package

readable

Source

sweet.lisp (file)

Constant: vertical-tab
Package

readable

Source

sweet.lisp (file)

Constant: whitespace-chars
Package

readable

Source

sweet.lisp (file)


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

5.2.2 Special variables

Special Variable: *bq-append*
Package

readable

Source

backquote.lisp (file)

Special Variable: *bq-clobberable*
Package

readable

Source

backquote.lisp (file)

Special Variable: *bq-list*
Package

readable

Source

backquote.lisp (file)

Special Variable: *bq-list**
Package

readable

Source

backquote.lisp (file)

Special Variable: *bq-nconc*
Package

readable

Source

backquote.lisp (file)

Special Variable: *bq-quote*
Package

readable

Source

backquote.lisp (file)

Special Variable: *bq-quote-nil*
Package

readable

Source

backquote.lisp (file)

Special Variable: *bq-simplify*
Package

readable

Source

backquote.lisp (file)

Special Variable: *circularity-counter*
Package

readable

Source

print.lisp (file)

Special Variable: *circularity-hash-table*
Package

readable

Source

print.lisp (file)

Special Variable: *comma*
Package

readable

Source

backquote.lisp (file)

Special Variable: *comma-atsign*
Package

readable

Source

backquote.lisp (file)

Special Variable: *comma-dot*
Package

readable

Source

backquote.lisp (file)

Special Variable: *constituents*
Package

readable

Source

neoteric.lisp (file)

Special Variable: *neoteric-readtable*

Use this table when about to read a neoteric expression

Package

readable

Source

neoteric.lisp (file)

Special Variable: *neoteric-underlying-readtable*

Use this table when reading neoteric atoms

Package

readable

Source

neoteric.lisp (file)

Special Variable: *readable-active*

Value of active readable notation for reading

Package

readable

Source

basic-curly.lisp (file)

Special Variable: *readable-in-print-error*
Package

readable

Source

print.lisp (file)

Special Variable: *suppress-print-errors*

Suppress printer errors when the condition is of the type designated by this variable: an unreadable object representing the error is printed instead.

Package

readable

Source

print.lisp (file)

Special Variable: *sweet-readtable*
Package

readable

Source

sweet.lisp (file)

Special Variable: *underlying-sweet-readtable*
Package

readable

Source

sweet.lisp (file)

Special Variable: neoteric-delimiters
Package

readable

Source

neoteric.lisp (file)

Special Variable: non-whitespace-indent
Package

readable

Source

sweet.lisp (file)


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

5.2.3 Macros

Macro: backquote X
Package

readable

Source

backquote.lisp (file)

Macro: define-constant NAME VALUE &optional DOC
Package

readable

Source

print.lisp (file)

Macro: let-splitter (FULL FIRST-VALUE SECOND-VALUE) EXPR &rest BODY
Package

readable

Source

sweet.lisp (file)


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

5.2.4 Functions

Function: accumulate-ichar STREAM
Package

readable

Source

sweet.lisp (file)

Function: allow-neoteric ()
Package

readable

Source

print.lisp (file)

Function: alternating-parameters LYST
Package

readable

Source

basic-curly.lisp (file)

Function: appende X Y
Package

readable

Source

sweet.lisp (file)

Function: as-brace-suffix X STREAM
Package

readable

Source

print.lisp (file)

Function: attach-sourceinfo POS VALUE
Package

readable

Source

sweet.lisp (file)

Function: bq-attach-append OP ITEM RESULT
Package

readable

Source

backquote.lisp (file)

Function: bq-attach-conses ITEMS RESULT
Package

readable

Source

backquote.lisp (file)

Function: bq-completely-process X
Package

readable

Source

backquote.lisp (file)

Function: bq-frob X
Package

readable

Source

backquote.lisp (file)

Function: bq-process X
Package

readable

Source

backquote.lisp (file)

Function: bq-remove-tokens X
Package

readable

Source

backquote.lisp (file)

Function: bq-simplify X
Package

readable

Source

backquote.lisp (file)

Function: bq-simplify-args X
Package

readable

Source

backquote.lisp (file)

Function: bq-splicing-frob X
Package

readable

Source

backquote.lisp (file)

Function: bracket X
Package

readable

Source

backquote.lisp (file)

Function: char-hspacep CHAR
Package

readable

Source

sweet.lisp (file)

Function: char-icharp CHAR
Package

readable

Source

sweet.lisp (file)

Function: char-line-endingp CHAR
Package

readable

Source

sweet.lisp (file)

Function: check-for-circularity OBJECT &optional ASSIGN MODE
Package

readable

Source

print.lisp (file)

Function: collecting-content STREAM
Package

readable

Source

sweet.lisp (file)

Function: compound-object-p X
Package

readable

Source

print.lisp (file)

Function: compute-sweet-redirect-readtable ()
Package

readable

Source

sweet.lisp (file)

Function: conse X Y
Package

readable

Source

sweet.lisp (file)

Function: consume-end-of-line STREAM
Package

readable

Source

sweet.lisp (file)

Function: consume-ff-vt STREAM
Package

readable

Source

sweet.lisp (file)

Function: consume-to-eol STREAM
Package

readable

Source

sweet.lisp (file)

Function: contains-only-punctuationp X
Package

readable

Source

print.lisp (file)

Function: curly-brace-infix-reader STREAM CHAR
Package

readable

Source

basic-curly.lisp (file)

Function: enable-basic-curly-real ()
Package

readable

Source

basic-curly.lisp (file)

Function: enable-full-curly-infix-real ()
Package

readable

Source

neoteric.lisp (file)

Function: enable-neoteric-real ()
Package

readable

Source

neoteric.lisp (file)

Function: enable-sweet-real ()
Package

readable

Source

sweet.lisp (file)

Function: eof-objectp C
Package

readable

Source

sweet.lisp (file)

Function: even-and-op-prefixp OP LYST
Package

readable

Source

basic-curly.lisp (file)

Function: full-curly-brace-infix-reader STREAM CHAR
Package

readable

Source

neoteric.lisp (file)

Function: get-next-indent STREAM
Package

readable

Source

sweet.lisp (file)

Function: get-sourceinfo STREAM
Package

readable

Source

sweet.lisp (file)

Function: handle-circularity MARKER STREAM
Package

readable

Source

print.lisp (file)

Function: hspaces STREAM
Package

readable

Source

sweet.lisp (file)

Function: indentation>=p INDENTATION1 INDENTATION2
Package

readable

Source

sweet.lisp (file)

Function: indentation>p INDENTATION1 INDENTATION2
Package

readable

Source

sweet.lisp (file)

Function: infix-tail OP X STREAM
Package

readable

Source

print.lisp (file)

Function: initial-indent-expr-tail STREAM
Package

readable

Source

sweet.lisp (file)

Function: is-infix-operatorp X
Package

readable

Source

print.lisp (file)

Function: it-expr STREAM STARTING-INDENT
Package

readable

Source

sweet.lisp (file)

Function: it-expr-real STREAM STARTING-INDENT
Package

readable

Source

sweet.lisp (file)

Function: lcomment-eolp C
Package

readable

Source

sweet.lisp (file)

Function: line-exprs STREAM INDENT
Package

readable

Source

sweet.lisp (file)

Function: list-no-longer-thanp X NUM-TO-GO
Package

readable

Source

print.lisp (file)

Function: list1e X
Package

readable

Source

sweet.lisp (file)

Function: list1p X
Package

readable

Source

print.lisp (file)

Function: list2e X Y
Package

readable

Source

sweet.lisp (file)

Function: list2p X
Package

readable

Source

print.lisp (file)

Function: long-and-boringp X NUM-TO-GO
Package

readable

Source

print.lisp (file)

Function: maptree FN X
Package

readable

Source

backquote.lisp (file)

Function: maybe-initial-abbrev STREAM ABBREV-PROCEDURE
Package

readable

Source

sweet.lisp (file)

Function: monify X
Package

readable

Source

sweet.lisp (file)

Function: my-append LHS RHS
Package

readable

Source

sweet.lisp (file)

Function: my-char-whitespacep C
Package

readable

Source

sweet.lisp (file)

Function: my-peek-char STREAM
Package

readable

Source

sweet.lisp (file)

Function: my-read-char STREAM
Package

readable

Source

sweet.lisp (file)

Function: my-read-datum INPUT-STREAM
Package

readable

Source

neoteric.lisp (file)

Function: my-read-delimited-list STOP-CHAR INPUT-STREAM
Package

readable

Source

neoteric.lisp (file)

Function: my-read-to-delimiter INPUT-STREAM START
Package

readable

Source

neoteric.lisp (file)

Function: n-expr STREAM
Package

readable

Source

sweet.lisp (file)

Function: n-expr-error STREAM FULL
Package

readable

Source

sweet.lisp (file)

Function: n-expr-first STREAM
Package

readable

Source

sweet.lisp (file)

Function: n-expr-or-scomment STREAM
Package

readable

Source

sweet.lisp (file)

Function: neoteric-curly-brace STREAM CHAR
Package

readable

Source

neoteric.lisp (file)

Function: neoteric-process-tail INPUT-STREAM PREFIX
Package

readable

Source

neoteric.lisp (file)

Function: neoteric-read-nocomment STREAM
Package

readable

Source

sweet.lisp (file)

Function: nest-comment STREAM
Package

readable

Source

sweet.lisp (file)

Function: null-or-quoted X
Package

readable

Source

backquote.lisp (file)

Function: out-synonym-of STREAM
Package

readable

Source

print.lisp (file)

Function: output-ugly-object-readable OBJECT STREAM
Package

readable

Source

print.lisp (file)

Function: post-period STREAM
Package

readable

Source

sweet.lisp (file)

Function: process-curly LYST
Package

readable

Source

basic-curly.lisp (file)

Function: read-body STREAM STARTING-INDENT
Package

readable

Source

sweet.lisp (file)

Function: read-error MESSAGE
Package

readable

Source

neoteric.lisp (file)

Function: represent-as-abbreviationp X
Package

readable

Source

print.lisp (file)

Function: represent-as-brace-suffixp X
Package

readable

Source

print.lisp (file)

Function: represent-as-infixp X
Package

readable

Source

print.lisp (file)

Function: represent-as-inline-infixp X
Package

readable

Source

print.lisp (file)

Function: rest-of-line STREAM INDENT
Package

readable

Source

sweet.lisp (file)

Function: setup-enable INTO
Package

readable

Source

basic-curly.lisp (file)

Function: setup-printer-state ()
Package

readable

Source

print.lisp (file)

Function: simple-infix-listp LYST
Package

readable

Source

basic-curly.lisp (file)

Function: skippable STOPPER STREAM
Package

readable

Source

sweet.lisp (file)

Function: string-before-delimiter INPUT-STREAM START
Package

readable

Source

neoteric.lisp (file)

Function: string-length S
Package

readable

Source

sweet.lisp (file)

Function: t-expr STREAM
Package

readable

Source

sweet.lisp (file)

Function: t-expr-entry STREAM CHAR
Package

readable

Source

sweet.lisp (file)

Function: t-expr-real STREAM
Package

readable

Source

sweet.lisp (file)

Function: transform-mixed-infix LYST
Package

readable

Source

basic-curly.lisp (file)

Function: uniquely-identified-by-print-p X
Package

readable

Source

print.lisp (file)

Function: wrap-comment-block STREAM SUB-CHAR INT
Package

readable

Source

sweet.lisp (file)

Function: wrap-comment-datum STREAM SUB-CHAR INT
Package

readable

Source

sweet.lisp (file)

Function: wrap-continue STREAM CHAR
Package

readable

Source

neoteric.lisp (file)

Function: wrap-dispatch-disabled-notail STREAM SUB-CHAR INT
Package

readable

Source

neoteric.lisp (file)

Function: wrap-dispatch-disabled-tail STREAM SUB-CHAR INT
Package

readable

Source

neoteric.lisp (file)

Function: wrap-dispatch-special-read-tail STREAM SUB-CHAR INT
Package

readable

Source

neoteric.lisp (file)

Function: wrap-dispatch-tail STREAM SUB-CHAR INT
Package

readable

Source

neoteric.lisp (file)

Function: wrap-paren STREAM CHAR
Package

readable

Source

neoteric.lisp (file)

Function: wrap-read-n-tail STREAM CHAR
Package

readable

Source

neoteric.lisp (file)

Function: write-abbreviation X STREAM
Package

readable

Source

print.lisp (file)

Function: write-list-contents X STREAM
Package

readable

Source

print.lisp (file)

Function: write-list-contents-rest X STREAM
Package

readable

Source

print.lisp (file)


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

5.2.5 Generic functions

Generic Function: text CONDITION
Package

readable

Methods
Method: text (CONDITION readable-parse-error)
Source

neoteric.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L   R  
Index Entry  Section

F
File, Lisp, readable.asd: The readable<dot>asd file
File, Lisp, readable/backquote.lisp: The readable/backquote<dot>lisp file
File, Lisp, readable/basic-curly.lisp: The readable/basic-curly<dot>lisp file
File, Lisp, readable/enablers.lisp: The readable/enablers<dot>lisp file
File, Lisp, readable/neoteric.lisp: The readable/neoteric<dot>lisp file
File, Lisp, readable/print.lisp: The readable/print<dot>lisp file
File, Lisp, readable/sweet.lisp: The readable/sweet<dot>lisp file

L
Lisp File, readable.asd: The readable<dot>asd file
Lisp File, readable/backquote.lisp: The readable/backquote<dot>lisp file
Lisp File, readable/basic-curly.lisp: The readable/basic-curly<dot>lisp file
Lisp File, readable/enablers.lisp: The readable/enablers<dot>lisp file
Lisp File, readable/neoteric.lisp: The readable/neoteric<dot>lisp file
Lisp File, readable/print.lisp: The readable/print<dot>lisp file
Lisp File, readable/sweet.lisp: The readable/sweet<dot>lisp file

R
readable.asd: The readable<dot>asd file
readable/backquote.lisp: The readable/backquote<dot>lisp file
readable/basic-curly.lisp: The readable/basic-curly<dot>lisp file
readable/enablers.lisp: The readable/enablers<dot>lisp file
readable/neoteric.lisp: The readable/neoteric<dot>lisp file
readable/print.lisp: The readable/print<dot>lisp file
readable/sweet.lisp: The readable/sweet<dot>lisp file

Jump to:   F   L   R  

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

A.2 Functions

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

A
accumulate-ichar: Internal functions
allow-neoteric: Internal functions
alternating-parameters: Internal functions
appende: Internal functions
as-brace-suffix: Internal functions
attach-sourceinfo: Internal functions

B
backquote: Internal macros
basic-curly-read: Exported functions
bq-attach-append: Internal functions
bq-attach-conses: Internal functions
bq-completely-process: Internal functions
bq-frob: Internal functions
bq-process: Internal functions
bq-remove-tokens: Internal functions
bq-simplify: Internal functions
bq-simplify-args: Internal functions
bq-splicing-frob: Internal functions
bracket: Internal functions

C
char-hspacep: Internal functions
char-icharp: Internal functions
char-line-endingp: Internal functions
check-for-circularity: Internal functions
collecting-content: Internal functions
compound-object-p: Internal functions
compute-sweet-redirect-readtable: Internal functions
conse: Internal functions
consume-end-of-line: Internal functions
consume-ff-vt: Internal functions
consume-to-eol: Internal functions
contains-only-punctuationp: Internal functions
curly-brace-infix-reader: Internal functions
curly-infix-read: Exported functions

D
define-constant: Internal macros
disable-readable: Exported functions

E
enable-basic-curly: Exported macros
enable-basic-curly-real: Internal functions
enable-curly-infix: Exported macros
enable-full-curly-infix: Exported macros
enable-full-curly-infix-real: Internal functions
enable-neoteric: Exported macros
enable-neoteric-real: Internal functions
enable-sweet: Exported macros
enable-sweet-real: Internal functions
eof-objectp: Internal functions
even-and-op-prefixp: Internal functions

F
full-curly-brace-infix-reader: Internal functions
Function, accumulate-ichar: Internal functions
Function, allow-neoteric: Internal functions
Function, alternating-parameters: Internal functions
Function, appende: Internal functions
Function, as-brace-suffix: Internal functions
Function, attach-sourceinfo: Internal functions
Function, basic-curly-read: Exported functions
Function, bq-attach-append: Internal functions
Function, bq-attach-conses: Internal functions
Function, bq-completely-process: Internal functions
Function, bq-frob: Internal functions
Function, bq-process: Internal functions
Function, bq-remove-tokens: Internal functions
Function, bq-simplify: Internal functions
Function, bq-simplify-args: Internal functions
Function, bq-splicing-frob: Internal functions
Function, bracket: Internal functions
Function, char-hspacep: Internal functions
Function, char-icharp: Internal functions
Function, char-line-endingp: Internal functions
Function, check-for-circularity: Internal functions
Function, collecting-content: Internal functions
Function, compound-object-p: Internal functions
Function, compute-sweet-redirect-readtable: Internal functions
Function, conse: Internal functions
Function, consume-end-of-line: Internal functions
Function, consume-ff-vt: Internal functions
Function, consume-to-eol: Internal functions
Function, contains-only-punctuationp: Internal functions
Function, curly-brace-infix-reader: Internal functions
Function, curly-infix-read: Exported functions
Function, disable-readable: Exported functions
Function, enable-basic-curly-real: Internal functions
Function, enable-full-curly-infix-real: Internal functions
Function, enable-neoteric-real: Internal functions
Function, enable-sweet-real: Internal functions
Function, eof-objectp: Internal functions
Function, even-and-op-prefixp: Internal functions
Function, full-curly-brace-infix-reader: Internal functions
Function, get-next-indent: Internal functions
Function, get-sourceinfo: Internal functions
Function, handle-circularity: Internal functions
Function, hspaces: Internal functions
Function, indentation>=p: Internal functions
Function, indentation>p: Internal functions
Function, infix-tail: Internal functions
Function, initial-indent-expr-tail: Internal functions
Function, is-infix-operatorp: Internal functions
Function, it-expr: Internal functions
Function, it-expr-real: Internal functions
Function, lcomment-eolp: Internal functions
Function, line-exprs: Internal functions
Function, list-no-longer-thanp: Internal functions
Function, list1e: Internal functions
Function, list1p: Internal functions
Function, list2e: Internal functions
Function, list2p: Internal functions
Function, long-and-boringp: Internal functions
Function, maptree: Internal functions
Function, maybe-initial-abbrev: Internal functions
Function, monify: Internal functions
Function, my-append: Internal functions
Function, my-char-whitespacep: Internal functions
Function, my-peek-char: Internal functions
Function, my-read-char: Internal functions
Function, my-read-datum: Internal functions
Function, my-read-delimited-list: Internal functions
Function, my-read-to-delimiter: Internal functions
Function, n-expr: Internal functions
Function, n-expr-error: Internal functions
Function, n-expr-first: Internal functions
Function, n-expr-or-scomment: Internal functions
Function, neoteric-curly-brace: Internal functions
Function, neoteric-process-tail: Internal functions
Function, neoteric-read: Exported functions
Function, neoteric-read-nocomment: Internal functions
Function, nest-comment: Internal functions
Function, null-or-quoted: Internal functions
Function, out-synonym-of: Internal functions
Function, output-object-readable: Exported functions
Function, output-ugly-object-readable: Internal functions
Function, post-period: Internal functions
Function, pprint-readable: Exported functions
Function, prin1-readable: Exported functions
Function, prin1-to-string-readable: Exported functions
Function, princ-readable: Exported functions
Function, princ-to-string-readable: Exported functions
Function, print-readable: Exported functions
Function, process-curly: Internal functions
Function, read-body: Internal functions
Function, read-error: Internal functions
Function, represent-as-abbreviationp: Internal functions
Function, represent-as-brace-suffixp: Internal functions
Function, represent-as-infixp: Internal functions
Function, represent-as-inline-infixp: Internal functions
Function, rest-of-line: Internal functions
Function, setup-enable: Internal functions
Function, setup-printer-state: Internal functions
Function, simple-infix-listp: Internal functions
Function, skippable: Internal functions
Function, string-before-delimiter: Internal functions
Function, string-length: Internal functions
Function, stringify-object-readable: Exported functions
Function, sweet-read: Exported functions
Function, t-expr: Internal functions
Function, t-expr-entry: Internal functions
Function, t-expr-real: Internal functions
Function, transform-mixed-infix: Internal functions
Function, uniquely-identified-by-print-p: Internal functions
Function, wrap-comment-block: Internal functions
Function, wrap-comment-datum: Internal functions
Function, wrap-continue: Internal functions
Function, wrap-dispatch-disabled-notail: Internal functions
Function, wrap-dispatch-disabled-tail: Internal functions
Function, wrap-dispatch-special-read-tail: Internal functions
Function, wrap-dispatch-tail: Internal functions
Function, wrap-paren: Internal functions
Function, wrap-read-n-tail: Internal functions
Function, write-abbreviation: Internal functions
Function, write-list-contents: Internal functions
Function, write-list-contents-rest: Internal functions
Function, write-readable: Exported functions
Function, write-to-string-readable: Exported functions

G
Generic Function, text: Internal generic functions
get-next-indent: Internal functions
get-sourceinfo: Internal functions

H
handle-circularity: Internal functions
hspaces: Internal functions

I
indentation>=p: Internal functions
indentation>p: Internal functions
infix-tail: Internal functions
initial-indent-expr-tail: Internal functions
is-infix-operatorp: Internal functions
it-expr: Internal functions
it-expr-real: Internal functions

L
lcomment-eolp: Internal functions
let-splitter: Internal macros
line-exprs: Internal functions
list-no-longer-thanp: Internal functions
list1e: Internal functions
list1p: Internal functions
list2e: Internal functions
list2p: Internal functions
long-and-boringp: Internal functions

M
Macro, backquote: Internal macros
Macro, define-constant: Internal macros
Macro, enable-basic-curly: Exported macros
Macro, enable-curly-infix: Exported macros
Macro, enable-full-curly-infix: Exported macros
Macro, enable-neoteric: Exported macros
Macro, enable-sweet: Exported macros
Macro, let-splitter: Internal macros
maptree: Internal functions
maybe-initial-abbrev: Internal functions
Method, text: Internal generic functions
monify: Internal functions
my-append: Internal functions
my-char-whitespacep: Internal functions
my-peek-char: Internal functions
my-read-char: Internal functions
my-read-datum: Internal functions
my-read-delimited-list: Internal functions
my-read-to-delimiter: Internal functions

N
n-expr: Internal functions
n-expr-error: Internal functions
n-expr-first: Internal functions
n-expr-or-scomment: Internal functions
neoteric-curly-brace: Internal functions
neoteric-process-tail: Internal functions
neoteric-read: Exported functions
neoteric-read-nocomment: Internal functions
nest-comment: Internal functions
null-or-quoted: Internal functions

O
out-synonym-of: Internal functions
output-object-readable: Exported functions
output-ugly-object-readable: Internal functions

P
post-period: Internal functions
pprint-readable: Exported functions
prin1-readable: Exported functions
prin1-to-string-readable: Exported functions
princ-readable: Exported functions
princ-to-string-readable: Exported functions
print-readable: Exported functions
process-curly: Internal functions

R
read-body: Internal functions
read-error: Internal functions
represent-as-abbreviationp: Internal functions
represent-as-brace-suffixp: Internal functions
represent-as-infixp: Internal functions
represent-as-inline-infixp: Internal functions
rest-of-line: Internal functions

S
setup-enable: Internal functions
setup-printer-state: Internal functions
simple-infix-listp: Internal functions
skippable: Internal functions
string-before-delimiter: Internal functions
string-length: Internal functions
stringify-object-readable: Exported functions
sweet-read: Exported functions

T
t-expr: Internal functions
t-expr-entry: Internal functions
t-expr-real: Internal functions
text: Internal generic functions
text: Internal generic functions
transform-mixed-infix: Internal functions

U
uniquely-identified-by-print-p: Internal functions

W
wrap-comment-block: Internal functions
wrap-comment-datum: Internal functions
wrap-continue: Internal functions
wrap-dispatch-disabled-notail: Internal functions
wrap-dispatch-disabled-tail: Internal functions
wrap-dispatch-special-read-tail: Internal functions
wrap-dispatch-tail: Internal functions
wrap-paren: Internal functions
wrap-read-n-tail: Internal functions
write-abbreviation: Internal functions
write-list-contents: Internal functions
write-list-contents-rest: Internal functions
write-readable: Exported functions
write-to-string-readable: Exported functions

Jump to:   A   B   C   D   E   F   G   H   I   L   M   N   O   P   R   S   T   U   W  

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

A.3 Variables

Jump to:   *  
A   B   C   D   E   F   G   H   I   L   M   N   P   S   T   V   W  
Index Entry  Section

*
*bq-append*: Internal special variables
*bq-clobberable*: Internal special variables
*bq-list*: Internal special variables
*bq-list**: Internal special variables
*bq-nconc*: Internal special variables
*bq-quote*: Internal special variables
*bq-quote-nil*: Internal special variables
*bq-simplify*: Internal special variables
*circularity-counter*: Internal special variables
*circularity-hash-table*: Internal special variables
*comma*: Internal special variables
*comma-atsign*: Internal special variables
*comma-dot*: Internal special variables
*constituents*: Internal special variables
*neoteric-readtable*: Internal special variables
*neoteric-underlying-readtable*: Internal special variables
*noisy*: Exported special variables
*original-readtable*: Exported special variables
*print-notation*: Exported special variables
*readable-active*: Internal special variables
*readable-in-print-error*: Internal special variables
*suppress-print-errors*: Internal special variables
*sweet-readtable*: Internal special variables
*underlying-sweet-readtable*: Internal special variables

A
abbreviations: Internal constants

B
boring-length: Internal constants

C
Constant, abbreviations: Internal constants
Constant, boring-length: Internal constants
Constant, datum-commentw-tag: Internal constants
Constant, empty-value: Internal constants
Constant, form-feed: Internal constants
Constant, group-split: Internal constants
Constant, group-split-char: Internal constants
Constant, hash-pipe-comment-nestsp: Internal constants
Constant, initial-comment-eol: Internal constants
Constant, line-ending-chars: Internal constants
Constant, my-eof-marker: Internal constants
Constant, no-neoteric-value: Internal constants
Constant, period-symbol: Internal constants
Constant, punct-chars: Internal constants
Constant, scomment-result: Internal constants
Constant, special-infix-operators: Internal constants
Constant, sublist: Internal constants
Constant, sublist-char: Internal constants
Constant, vertical-tab: Internal constants
Constant, whitespace-chars: Internal constants

D
datum-commentw-tag: Internal constants

E
empty-value: Internal constants

F
form-feed: Internal constants

G
group-split: Internal constants
group-split-char: Internal constants

H
hash-pipe-comment-nestsp: Internal constants

I
initial-comment-eol: Internal constants

L
line-ending-chars: Internal constants

M
my-char-code-limit: Exported special variables
my-eof-marker: Internal constants

N
neoteric-delimiters: Internal special variables
no-neoteric-value: Internal constants
non-whitespace-indent: Internal special variables

P
period-symbol: Internal constants
punct-chars: Internal constants

S
scomment-result: Internal constants
Slot, text: Exported conditions
Special Variable, *bq-append*: Internal special variables
Special Variable, *bq-clobberable*: Internal special variables
Special Variable, *bq-list*: Internal special variables
Special Variable, *bq-list**: Internal special variables
Special Variable, *bq-nconc*: Internal special variables
Special Variable, *bq-quote*: Internal special variables
Special Variable, *bq-quote-nil*: Internal special variables
Special Variable, *bq-simplify*: Internal special variables
Special Variable, *circularity-counter*: Internal special variables
Special Variable, *circularity-hash-table*: Internal special variables
Special Variable, *comma*: Internal special variables
Special Variable, *comma-atsign*: Internal special variables
Special Variable, *comma-dot*: Internal special variables
Special Variable, *constituents*: Internal special variables
Special Variable, *neoteric-readtable*: Internal special variables
Special Variable, *neoteric-underlying-readtable*: Internal special variables
Special Variable, *noisy*: Exported special variables
Special Variable, *original-readtable*: Exported special variables
Special Variable, *print-notation*: Exported special variables
Special Variable, *readable-active*: Internal special variables
Special Variable, *readable-in-print-error*: Internal special variables
Special Variable, *suppress-print-errors*: Internal special variables
Special Variable, *sweet-readtable*: Internal special variables
Special Variable, *underlying-sweet-readtable*: Internal special variables
Special Variable, my-char-code-limit: Exported special variables
Special Variable, neoteric-delimiters: Internal special variables
Special Variable, non-whitespace-indent: Internal special variables
special-infix-operators: Internal constants
sublist: Internal constants
sublist-char: Internal constants

T
text: Exported conditions

V
vertical-tab: Internal constants

W
whitespace-chars: Internal constants

Jump to:   *  
A   B   C   D   E   F   G   H   I   L   M   N   P   S   T   V   W  

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

A.4 Data types

Jump to:   C   P   R   S  
Index Entry  Section

C
Condition, readable-parse-error: Exported conditions

P
Package, readable: The readable package
Package, readable-asd: The readable-asd package

R
readable: The readable system
readable: The readable package
readable-asd: The readable-asd package
readable-parse-error: Exported conditions

S
System, readable: The readable system

Jump to:   C   P   R   S