The jsown Reference Manual

This is the jsown Reference Manual, version 1.0.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sun Sep 15 05:36:06 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 jsown

Fast JSON parsing library. Mainly geared torwards fetching only a few keys of many objects, but efficient for other types of content too

Maintainer

Aad Versteden <>

Author

Aad Versteden <>

License

MIT

Version

1.0.1

Source

jsown.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 jsown/jsown.asd

Source

jsown.asd.

Parent Component

jsown (system).

ASDF Systems

jsown.


3.1.2 jsown/packages.lisp

Source

jsown.asd.

Parent Component

jsown (system).

Packages

jsown.


3.1.3 jsown/accessors.lisp

Dependency

packages.lisp (file).

Source

jsown.asd.

Parent Component

jsown (system).

Public Interface
Internals

3.1.4 jsown/reader.lisp

Dependency

accessors.lisp (file).

Source

jsown.asd.

Parent Component

jsown (system).

Public Interface
Internals

3.1.5 jsown/writer.lisp

Dependency

reader.lisp (file).

Source

jsown.asd.

Parent Component

jsown (system).

Public Interface
Internals

4 Packages

Packages are listed by definition order.


4.1 jsown

Source

packages.lisp.

Use List

common-lisp.

Public Interface
Internals

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: *parsed-empty-list-value*

value to emit when parsing a json empty list ’[]’

Package

jsown.

Source

reader.lisp.

Special Variable: *parsed-false-value*

value to emit when parsing json’s ’false’

Package

jsown.

Source

reader.lisp.

Special Variable: *parsed-null-value*

value to emit when parsing json’s ’null’

Package

jsown.

Source

reader.lisp.

Special Variable: *parsed-true-value*

value to emit when parsing json’s ’true’

Package

jsown.

Source

reader.lisp.


5.1.2 Macros

Macro: do-json-keys ((key val) object &body body)

Iterates over the json key-value pairs

Package

jsown.

Source

accessors.lisp.

Macro: extend-js (obj &body specs)

fills in a bunch of jsown values for obj. each spec should contain a list with the first element being the string which represents the key and the second being the form which evaluates to the value to which the key should be set.

it is heavily related to jsown-object, which fills in an empty object.

eg: (jsown-values (empty-object)
("kind" "onyx.Groupbox")
("components" (list (jsown-object
("content" "Hello World")
("tag" "h1"))
(jsown-object ("tag" "p") ("content" "This is jsown talkin!")))))

Package

jsown.

Source

accessors.lisp.

Macro: filter (value &rest specs)

Fancy filtering for jsown-parsed objects.
spec can be one of the following:
[object] key to find. will transform into (jsown:val value key)
[cl:map] use this modifier with an [object] modifier after it, to filter all elements in the list.

Package

jsown.

Source

reader.lisp.

Macro: new-js (&body specs)

creates a new empty object and fills it is per jsown-values

Package

jsown.

Source

accessors.lisp.

Macro: with-injective-reader (&body body)

Rebinds *parsed-*-value* so that reading json documents is injective and converting them back to json yields roughly the same document as the original. Rebinds:
- *parsed-true-value* => :true
- *parsed-false-value* => :false
- *parsed-null-value* => :null

Package

jsown.

Source

reader.lisp.


5.1.3 Compiler macros

Compiler Macro: build-key-container (&rest keywords-to-read)
Package

jsown.

Source

reader.lisp.

Compiler Macro: parse (string &rest keywords-to-read)
Package

jsown.

Source

reader.lisp.


5.1.4 Setf expanders

Setf Expander: (setf val) (place key)

see (setf getf) and val

Package

jsown.

Source

accessors.lisp.

Reader

val (function).


5.1.5 Ordinary functions

Function: as-js-bool (value)

returns <value> as a boolean value (in jsown format)

Package

jsown.

Source

writer.lisp.

Function: as-js-null (value)

returns <value> with nil being javascript’s null (in jsown format).

Package

jsown.

Source

writer.lisp.

Function: build-key-container (&rest keywords-to-read)

Builds an internal structure to speed up the keywords which you can read. This should be used when the keywords needed are not known at compiletime, but you still want to parse those keywords of a lot of documents. If the keywords you are interested in are known at compiletime, the use of #’parse will automatically expand the kewords at compiletime.
parse-with-container takes the result of this function and will return the keywords which have been inserted here.

Package

jsown.

Source

reader.lisp.

Function: empty-object ()

Returns an empty object which can be used to build new objects upon

Package

jsown.

Source

accessors.lisp.

Function: keyp (object key)

Returns non-nil iff <object> has key <key>.

Package

jsown.

Source

accessors.lisp.

Function: keywords (object)

Returns a list of all the keywords contained in the object

Package

jsown.

Source

accessors.lisp.

Function: parse (string &rest keywords-to-read)

Reads a json object from the given string, with the given keywords being the keywords which are fetched from the object. All parse functions assume <string> is not an empty json object. (string/= string "{}")

Package

jsown.

Source

reader.lisp.

Function: parse-with-container (json-string container)

Parses the keywords which have been specified in the container from the json string json-string.
For most cases you can just use the parse function without a special key container. This is only here to support some cases where the building of the key container takes too much time. See #’parse for the normal variant.
See #’build-key-container for a way to build new keyword containers.

Package

jsown.

Source

reader.lisp.

Function: remkey (object key)

Removes key from object.

Package

jsown.

Source

accessors.lisp.

Function: to-json* (object)

Converts an object in internal jsown representation to a string containing the json representation

Package

jsown.

Source

writer.lisp.

Function: val (object key)

Returns the value of the given key in object

Package

jsown.

Source

accessors.lisp.

Setf expander for this function

(setf val).

Function: val-safe (object key)

Returns the value of <key> in <object> if <object> existed, or nil if it did not. A second value is returned which indicates whether or not the key was found.

Package

jsown.

Source

accessors.lisp.


5.1.6 Generic functions

Generic Function: to-json (object)

Writes the given object to json in a generic way.

Package

jsown.

Source

writer.lisp.

Methods
Method: to-json ((n (eql nil)))
Method: to-json ((empty-list (eql :empty-list)))
Method: to-json ((false (eql :n)))
Method: to-json ((false (eql :null)))
Method: to-json ((false (eql :f)))
Method: to-json ((false (eql :false)))
Method: to-json ((true (eql :true)))
Method: to-json ((true (eql :t)))
Method: to-json ((true (eql t)))
Method: to-json ((s symbol))
Method: to-json ((table hash-table))
Method: to-json ((array array))
Method: to-json ((list list))
Method: to-json ((float float))
Method: to-json ((ratio ratio))
Method: to-json ((number number))
Method: to-json ((string string))
Method: to-json ((content json-encoded-content))

5.1.7 Standalone methods

Method: initialize-instance ((jec json-encoded-content) &key content unencoded-content &allow-other-keys)
Source

writer.lisp.


5.1.8 Classes

Class: json-encoded-content

describes a json object whos content is serialized already.

Package

jsown.

Source

writer.lisp.

Direct methods
Direct slots
Slot: content
Initargs

:content

Readers

content.

Writers

This slot is read-only.


5.2 Internals


5.2.1 Constants

Constant: +assume-fixnums+

Compiles under the expectation that numbers (being integers and the float and non-float part of floats are fixnums. By default this is turned off. The performance hit seems to be around 2% to 8% in the mixed reader speed test.

Package

jsown.

Source

reader.lisp.

Constant: +compile-unescape-json-strings+

Compiles support for unescaping json strings.
If you set this to nil upon compilation time strings and keywords aren’t escaped. This makes the library incompliant with json, but it does make it a few % faster. Could be handy when used in a mapreduce situation where you don’t mind debugging and speed is of utmost importance.

Package

jsown.

Source

reader.lisp.


5.2.2 Macros

Macro: read-number* (buffer &key currently-reading exponent-p float-p float-delimiters exp-delimiters number-delimiters)

This macro should be compared to inlined functions with respect to speed. The macro creates a tree of spaghetti code that can read jsown numbers to lisp numbers.

Package

jsown.

Source

reader.lisp.

Macro: set-read-number-part (currently-reading buffer &body body)
Package

jsown.

Source

reader.lisp.


5.2.3 Compiler macros

Compiler Macro: build-character-tree (&rest strings)
Package

jsown.

Source

reader.lisp.


5.2.4 Ordinary functions

Function: append-key (object key value)

Appends the given key to the object

Package

jsown.

Source

accessors.lisp.

Reader: buffer-index (instance)
Writer: (setf buffer-index) (instance)
Package

jsown.

Source

reader.lisp.

Target Slot

index.

Reader: buffer-mark (instance)
Writer: (setf buffer-mark) (instance)
Package

jsown.

Source

reader.lisp.

Target Slot

mark.

Function: buffer-p (object)
Package

jsown.

Source

reader.lisp.

Reader: buffer-string (instance)
Writer: (setf buffer-string) (instance)
Package

jsown.

Source

reader.lisp.

Target Slot

string.

Function: build-buffer (string)

Makes a new buffer and ensures the string is of the correct type

Package

jsown.

Source

reader.lisp.

Function: build-character-tree (&rest strings)

Builds a character tree from a set of strings

Package

jsown.

Source

reader.lisp.

Function: build-tree (lists)

Builds a tree from a range of lists and a function to compare its elements by

Package

jsown.

Source

reader.lisp.

Function: char-in-arr (char char-arr)

Returns t if <char> is found in <char-arr>, returns nil otherwise

Package

jsown.

Source

reader.lisp.

Function: copy-buffer (instance)
Package

jsown.

Source

reader.lisp.

Function: current-char (buffer)

Returns the current character the buffer is pointing to

Package

jsown.

Source

reader.lisp.

Function: decr-char (buffer)

Sets the pointer to the previous char in the buffer

Package

jsown.

Source

reader.lisp.

Function: fetch-char (buffer)

Reads a character from the buffer and increases the index

Package

jsown.

Source

reader.lisp.

Function: find-first-elts (lists)
Package

jsown.

Source

reader.lisp.

Function: high-surrogate-p (code-value)

character numbers between U+D800 and U+DFFF (inclusive) are reserved for use with the UTF-16 encoding form (as surrogate pairs) and do not directly represent characters.

Package

jsown.

Source

reader.lisp.

Function: iterate-tree (tree char)

Iterates a character-tree with the given character
Returns two values, being the new tree and whether or not this is an end-point.

Package

jsown.

Source

reader.lisp.

Function: jsown-object-p (object)

returns non-nil iff we expect <object> to be a jsown object.

Package

jsown.

Source

accessors.lisp.

Function: key-val (object key)

Returns the list which represents the key-val pair in the json object

Package

jsown.

Source

accessors.lisp.

Function: list-is-object-p (list)
Package

jsown.

Source

writer.lisp.

Function: list-to-json (list)
Package

jsown.

Source

writer.lisp.

Function: make-buffer (&key string index mark)
Package

jsown.

Source

reader.lisp.

Function: make-jsown-filter (value first-spec &rest other-specs)

Fancy filtering for jsown-parsed objects, functional implementation. look at jsown-filter for a working version.

Package

jsown.

Source

reader.lisp.

Function: mark-buffer (buffer)

Sets the mark of the buffer to the current character

Package

jsown.

Source

reader.lisp.

Function: mark-length (buffer)

Returns the current amount of characters in the marked piece of the buffer

Package

jsown.

Source

reader.lisp.

Function: next-char (buffer)

Sets the pointer to the next char in the buffer

Package

jsown.

Source

reader.lisp.

Function: next-char/ (buffer)

Sets the pointer to the next char in the buffer, ignores escaped characters (they start with a \) through

Package

jsown.

Source

reader.lisp.

Function: next-char/i (buffer)

Does what next-char/ does, but returns nil if no char was skipped or t if a char was skipped.

Package

jsown.

Source

reader.lisp.

Function: object-to-json (list)
Package

jsown.

Source

writer.lisp.

Function: overwrite-val (object key value)

Overwrites the given key’s value with value. Errors out if the key didn’t exist

Package

jsown.

Source

accessors.lisp.

Function: parse-string (buffer)

Reads a JSON string from the stream
PRE: assumes the buffer’s index is at the starting "
POST: returns the matching string without converting escaped characters to their internal representation POST: the buffer’s index is right after the ending "

Package

jsown.

Source

reader.lisp.

Function: peek-behind-char (buffer)
Package

jsown.

Source

reader.lisp.

Function: push-key (object key value)

Adds the given key to the object at front

Package

jsown.

Source

accessors.lisp.

Function: read-array (buffer)

Reads a JSON array from the stream
PRE: assumes the buffer’s index is at the starting [ POST: returns a list containing all read objects POST: the buffer’s index is right after the ending ]

Package

jsown.

Source

reader.lisp.

Function: read-key (buffer)

Reads a key from the key-value list.
PRE: Assumes the buffer’s index is at the starting " of the key POST: The buffer’s index is right after the ending " of the key

Package

jsown.

Source

reader.lisp.

Function: read-number (buffer)

Reads a number from the buffer.
PRE: assumes the index is pointing to the first character representing the number
POST: the value of the character is returned
POST: the buffer’s index is at the position right after the last character representing the number

Package

jsown.

Source

reader.lisp.

Function: read-object (buffer)

reads an object, starting with { and ending with } into a in internal jsown object

Package

jsown.

Source

reader.lisp.

Function: read-partial-key (buffer tree)

reads a key from the buffer.
PRE: Assumes the buffer’s index is at the starting " of the key
POST: Returns (values key t) if the key was found as a valid key in the tree, or (values nil nil) if it was not POST: The buffer’s index is right after the ending " of the key

Package

jsown.

Source

reader.lisp.

Function: read-partial-object (buffer tree)

Reads an object from the buffer, but only when the key matches a key in the tree

Package

jsown.

Source

reader.lisp.

Function: read-value (buffer)

Reads a value from the stream.
This searches for the first meaningful character, and delegates to the right function for that character

Package

jsown.

Source

reader.lisp.

Function: skip-array (buffer)

Skips the contents of an array from the buffer PRE: assumes the buffer’s index is at the starting [ POST: the buffer’s index is right after the ending ]

Package

jsown.

Source

reader.lisp.

Function: skip-key (buffer)

Skips a key from the key-value list.
PRE: Assumes the buffer’s index is at the starting " of the key POST: The buffer’s index is right after the ending " of the key

Package

jsown.

Source

reader.lisp.

Function: skip-number (buffer)

Skips a number from the buffer
PRE: assumes the index is pointing to the first character representing the number.
POST: the buffer’s index is at the position right after the last character representing the number, possibly skipping spaces after that position

Package

jsown.

Source

reader.lisp.

Function: skip-object (buffer)

Skips an object from the buffer
PRE: Assumes the buffer’s index is at the starting { of the object POST: The buffer’s index is right after the ending } of the object

Package

jsown.

Source

reader.lisp.

Function: skip-string (buffer)

Skips the contents of an input string from the buffer. PRE: assumes the buffer’s index is at the starting " POST: the buffer’s index is right after the ending "

Package

jsown.

Source

reader.lisp.

Function: skip-to (buffer last-char)

Skips characters until <char> has been found. <char> is the last char which is skipped see: skip-until

Package

jsown.

Source

reader.lisp.

Function: skip-to/ (buffer last-char)

What skip-to does, but with the ignoring of \

Package

jsown.

Source

reader.lisp.

Function: skip-until (buffer last-char)

Skips characters until <char> has been found. <char> is NOT skipped See: skip-to

Package

jsown.

Source

reader.lisp.

Function: skip-until* (buffer char-arr)

Skips characters until one of the characters in <char-arr> has been found. The character which was found is not read from the buffer.

Package

jsown.

Source

reader.lisp.

Function: skip-until/ (buffer last-char)

What skip-until does, but with \ escaping

Package

jsown.

Source

reader.lisp.

Function: skip-value (buffer)

Skips a value from the stream.
This searches for the first meaningful character, and delegates to the right function for skipping that

Package

jsown.

Source

reader.lisp.

Function: subseq-buffer-mark (buffer)

Returns the content between index and mark for the current buffer result: (subseq buffer-string mark index))

Package

jsown.

Source

reader.lisp.

Function: subseq-tree (buffer end-char tree)

Returns a sequence of the buffer, reading everything that matches with the given tree before end-char is found. end-char is not read from the buffer Returns nil if no sequence matching the tree could be found. It then stops iterating at the failed position
Skips #\

Package

jsown.

Source

reader.lisp.

Function: subseq-until (buffer char-arr)

Returns a subsequence of stream, reading everything before a character belonging to char-arr is found. The character which was found is not read from the buffer

Package

jsown.

Source

reader.lisp.

Function: subseq-until/ (buffer last-char)

Does what subseq-until does, but does escaping too

Package

jsown.

Source

reader.lisp.

Function: subseq-until/unescape (buffer last-char)

Does what subseq-until/ does, but unescapes the returned string

Package

jsown.

Source

reader.lisp.

Function: supplementary-plane-p (char-code)

character numbers between U+010000 and U+10FFFF (inclusive) are encoded as a surrogate pair.

Package

jsown.

Source

writer.lisp.

Function: test-reader-speed (iterations)
Package

jsown.

Source

reader.lisp.

Function: unescape-string/count (buffer count)

Unescapes the given string based on JSOWN’s spec

Package

jsown.

Source

reader.lisp.

Function: write-number* (object output)
Package

jsown.

Source

writer.lisp.

Function: write-object-to-stream (object output)
Package

jsown.

Source

writer.lisp.

Function: write-string* (object output)
Package

jsown.

Source

writer.lisp.


5.2.5 Generic functions

Generic Reader: content (object)
Package

jsown.

Methods
Reader Method: content ((json-encoded-content json-encoded-content))

automatically generated reader method

Source

writer.lisp.

Target Slot

content.


5.2.6 Structures

Structure: buffer

A string-buffer which is used to operate on the strings
The use of a string-buffer allows us to read the data in bulk, and to operate on it, by using simple index manipulations. Reading the string up front removes the hassle of having a fixed-size maximal input

Package

jsown.

Source

reader.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: string
Package

common-lisp.

Type

simple-string

Initform

""

Readers

buffer-string.

Writers

(setf buffer-string).

Slot: index
Type

fixnum

Initform

0

Readers

buffer-index.

Writers

(setf buffer-index).

Slot: mark
Type

fixnum

Initform

0

Readers

buffer-mark.

Writers

(setf buffer-mark).


Appendix A Indexes


A.1 Concepts


A.2 Functions

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

(
(setf buffer-index): Private ordinary functions
(setf buffer-mark): Private ordinary functions
(setf buffer-string): Private ordinary functions
(setf val): Public setf expanders

A
append-key: Private ordinary functions
as-js-bool: Public ordinary functions
as-js-null: Public ordinary functions

B
buffer-index: Private ordinary functions
buffer-mark: Private ordinary functions
buffer-p: Private ordinary functions
buffer-string: Private ordinary functions
build-buffer: Private ordinary functions
build-character-tree: Private compiler macros
build-character-tree: Private ordinary functions
build-key-container: Public compiler macros
build-key-container: Public ordinary functions
build-tree: Private ordinary functions

C
char-in-arr: Private ordinary functions
Compiler Macro, build-character-tree: Private compiler macros
Compiler Macro, build-key-container: Public compiler macros
Compiler Macro, parse: Public compiler macros
content: Private generic functions
content: Private generic functions
copy-buffer: Private ordinary functions
current-char: Private ordinary functions

D
decr-char: Private ordinary functions
do-json-keys: Public macros

E
empty-object: Public ordinary functions
extend-js: Public macros

F
fetch-char: Private ordinary functions
filter: Public macros
find-first-elts: Private ordinary functions
Function, (setf buffer-index): Private ordinary functions
Function, (setf buffer-mark): Private ordinary functions
Function, (setf buffer-string): Private ordinary functions
Function, append-key: Private ordinary functions
Function, as-js-bool: Public ordinary functions
Function, as-js-null: Public ordinary functions
Function, buffer-index: Private ordinary functions
Function, buffer-mark: Private ordinary functions
Function, buffer-p: Private ordinary functions
Function, buffer-string: Private ordinary functions
Function, build-buffer: Private ordinary functions
Function, build-character-tree: Private ordinary functions
Function, build-key-container: Public ordinary functions
Function, build-tree: Private ordinary functions
Function, char-in-arr: Private ordinary functions
Function, copy-buffer: Private ordinary functions
Function, current-char: Private ordinary functions
Function, decr-char: Private ordinary functions
Function, empty-object: Public ordinary functions
Function, fetch-char: Private ordinary functions
Function, find-first-elts: Private ordinary functions
Function, high-surrogate-p: Private ordinary functions
Function, iterate-tree: Private ordinary functions
Function, jsown-object-p: Private ordinary functions
Function, key-val: Private ordinary functions
Function, keyp: Public ordinary functions
Function, keywords: Public ordinary functions
Function, list-is-object-p: Private ordinary functions
Function, list-to-json: Private ordinary functions
Function, make-buffer: Private ordinary functions
Function, make-jsown-filter: Private ordinary functions
Function, mark-buffer: Private ordinary functions
Function, mark-length: Private ordinary functions
Function, next-char: Private ordinary functions
Function, next-char/: Private ordinary functions
Function, next-char/i: Private ordinary functions
Function, object-to-json: Private ordinary functions
Function, overwrite-val: Private ordinary functions
Function, parse: Public ordinary functions
Function, parse-string: Private ordinary functions
Function, parse-with-container: Public ordinary functions
Function, peek-behind-char: Private ordinary functions
Function, push-key: Private ordinary functions
Function, read-array: Private ordinary functions
Function, read-key: Private ordinary functions
Function, read-number: Private ordinary functions
Function, read-object: Private ordinary functions
Function, read-partial-key: Private ordinary functions
Function, read-partial-object: Private ordinary functions
Function, read-value: Private ordinary functions
Function, remkey: Public ordinary functions
Function, skip-array: Private ordinary functions
Function, skip-key: Private ordinary functions
Function, skip-number: Private ordinary functions
Function, skip-object: Private ordinary functions
Function, skip-string: Private ordinary functions
Function, skip-to: Private ordinary functions
Function, skip-to/: Private ordinary functions
Function, skip-until: Private ordinary functions
Function, skip-until*: Private ordinary functions
Function, skip-until/: Private ordinary functions
Function, skip-value: Private ordinary functions
Function, subseq-buffer-mark: Private ordinary functions
Function, subseq-tree: Private ordinary functions
Function, subseq-until: Private ordinary functions
Function, subseq-until/: Private ordinary functions
Function, subseq-until/unescape: Private ordinary functions
Function, supplementary-plane-p: Private ordinary functions
Function, test-reader-speed: Private ordinary functions
Function, to-json*: Public ordinary functions
Function, unescape-string/count: Private ordinary functions
Function, val: Public ordinary functions
Function, val-safe: Public ordinary functions
Function, write-number*: Private ordinary functions
Function, write-object-to-stream: Private ordinary functions
Function, write-string*: Private ordinary functions

G
Generic Function, content: Private generic functions
Generic Function, to-json: Public generic functions

H
high-surrogate-p: Private ordinary functions

I
initialize-instance: Public standalone methods
iterate-tree: Private ordinary functions

J
jsown-object-p: Private ordinary functions

K
key-val: Private ordinary functions
keyp: Public ordinary functions
keywords: Public ordinary functions

L
list-is-object-p: Private ordinary functions
list-to-json: Private ordinary functions

M
Macro, do-json-keys: Public macros
Macro, extend-js: Public macros
Macro, filter: Public macros
Macro, new-js: Public macros
Macro, read-number*: Private macros
Macro, set-read-number-part: Private macros
Macro, with-injective-reader: Public macros
make-buffer: Private ordinary functions
make-jsown-filter: Private ordinary functions
mark-buffer: Private ordinary functions
mark-length: Private ordinary functions
Method, content: Private generic functions
Method, initialize-instance: Public standalone methods
Method, to-json: Public generic functions
Method, to-json: Public generic functions
Method, to-json: Public generic functions
Method, to-json: Public generic functions
Method, to-json: Public generic functions
Method, to-json: Public generic functions
Method, to-json: Public generic functions
Method, to-json: Public generic functions
Method, to-json: Public generic functions
Method, to-json: Public generic functions
Method, to-json: Public generic functions
Method, to-json: Public generic functions
Method, to-json: Public generic functions
Method, to-json: Public generic functions
Method, to-json: Public generic functions
Method, to-json: Public generic functions
Method, to-json: Public generic functions
Method, to-json: Public generic functions

N
new-js: Public macros
next-char: Private ordinary functions
next-char/: Private ordinary functions
next-char/i: Private ordinary functions

O
object-to-json: Private ordinary functions
overwrite-val: Private ordinary functions

P
parse: Public compiler macros
parse: Public ordinary functions
parse-string: Private ordinary functions
parse-with-container: Public ordinary functions
peek-behind-char: Private ordinary functions
push-key: Private ordinary functions

R
read-array: Private ordinary functions
read-key: Private ordinary functions
read-number: Private ordinary functions
read-number*: Private macros
read-object: Private ordinary functions
read-partial-key: Private ordinary functions
read-partial-object: Private ordinary functions
read-value: Private ordinary functions
remkey: Public ordinary functions

S
set-read-number-part: Private macros
Setf Expander, (setf val): Public setf expanders
skip-array: Private ordinary functions
skip-key: Private ordinary functions
skip-number: Private ordinary functions
skip-object: Private ordinary functions
skip-string: Private ordinary functions
skip-to: Private ordinary functions
skip-to/: Private ordinary functions
skip-until: Private ordinary functions
skip-until*: Private ordinary functions
skip-until/: Private ordinary functions
skip-value: Private ordinary functions
subseq-buffer-mark: Private ordinary functions
subseq-tree: Private ordinary functions
subseq-until: Private ordinary functions
subseq-until/: Private ordinary functions
subseq-until/unescape: Private ordinary functions
supplementary-plane-p: Private ordinary functions

T
test-reader-speed: Private ordinary functions
to-json: Public generic functions
to-json: Public generic functions
to-json: Public generic functions
to-json: Public generic functions
to-json: Public generic functions
to-json: Public generic functions
to-json: Public generic functions
to-json: Public generic functions
to-json: Public generic functions
to-json: Public generic functions
to-json: Public generic functions
to-json: Public generic functions
to-json: Public generic functions
to-json: Public generic functions
to-json: Public generic functions
to-json: Public generic functions
to-json: Public generic functions
to-json: Public generic functions
to-json: Public generic functions
to-json*: Public ordinary functions

U
unescape-string/count: Private ordinary functions

V
val: Public ordinary functions
val-safe: Public ordinary functions

W
with-injective-reader: Public macros
write-number*: Private ordinary functions
write-object-to-stream: Private ordinary functions
write-string*: Private ordinary functions