The jonathan Reference Manual

This is the jonathan Reference Manual, version 0.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed May 15 05:39:03 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 jonathan

High performance JSON encoder and decoder. Currently support: SBCL, CCL.

Author

Rudolph-Miller

License

MIT

Long Description

# Jonathan

[![Build Status](https://circleci.com/gh/Rudolph-Miller/jonathan.svg?style=shield)](https://circleci.com/gh/Rudolph-Miller/jonathan)
[![Build Status](https://travis-ci.org/Rudolph-Miller/jonathan.svg?branch=master)](https://travis-ci.org/Rudolph-Miller/jonathan)
[![Coverage Status](https://coveralls.io/repos/Rudolph-Miller/jonathan/badge.svg?branch=master)](https://coveralls.io/r/Rudolph-Miller/jonathan?branch=master) [![Quicklisp dist](http://quickdocs.org/badge/jonathan.svg)](http://quickdocs.org/jonathan/)

JSON encoder and decoder.
It’s faster than [jsown](https://github.com/madnificent/jsown) - high performance Common Lisp json parser.

See [Document](http://rudolph-miller.github.io/jonathan/overview.html).
This HTML is generated by [Codex](https://github.com/CommonDoc/codex).

## Usage

“‘Lisp
(to-json ’(:name "Common Lisp" :born 1984 :impls (SBCL KCL)))
;; => "{\"NAME\":\"Common Lisp\",\"BORN\":1984,\"IMPLS\":[\"SBCL\",\"KCL\"]}"

(to-json ’(:name "Common Lisp" :born 1984 :impls (SBCL KCL))
:octets t)
;; => #(123 34 78 65 77 69 34 58 34 67 111 109 109 111 110 32 76 ...)

(to-json ’((:name . "Common Lisp") (:born . 1984) (:impls SBCL KCL))
:from :alist)
;; => "{\"NAME\":\"Common Lisp\",\"BORN\":1984,\"IMPLS\":[\"SBCL\",\"KCL\"]}"

(to-json ’(:obj (:name . "Common Lisp") (:born . 1984) (:impls SBCL KCL))
:from :jsown)
;; => "{\"NAME\":\"Common Lisp\",\"BORN\":1984,\"IMPLS\":[\"SBCL\",\"KCL\"]}"

(let ((encoder (compile-encoder (:from :alist) (name)
‘(("name" . ,name)))))
(funcall encoder "Rudolph"))
;; => "{\"name\":\"Rudolph\"}"

(parse "{\"NAME\":\"Common Lisp\",\"BORN\":1984,\"IMPLS\":[\"SBCL\",\"KCL\"]}")
;; => (:NAME "Common Lisp" :BORN 1984 :IMPLS ("SBCL" "CCL" "KCL"))

(parse "{\"NAME\":\"Common Lisp\",\"BORN\":1984,\"IMPLS\":[\"SBCL\",\"KCL\"]}"
:as :alist)
;; => (("NAME" . "Common Lisp") ("BORN" . 1984) ("IMPLS" "SBCL" "CCL" "KCL"))

(parse "{\"NAME\":\"Common Lisp\",\"BORN\":1984,\"IMPLS\":[\"SBCL\",\"KCL\"]}"
:as :jsown)
;; => (:obj ("NAME" . "Common Lisp") ("BORN" . 1984) ("IMPLS" "SBCL" "CCL" "KCL"))

(parse "{\"NAME\":\"Common Lisp\",\"BORN\":1984,\"IMPLS\":[\"SBCL\",\"KCL\"]}"
:as :hash-table)
;; => #<HASH-TABLE :TEST EQUAL :COUNT 3>
“‘

## Installasion

“‘Lisp
(ql:quickload :jonathan)
“‘

## to-json
- can encode Object into JSON format.
- Restricted Property List. (‘:from :plist‘)
- Association List. (‘:from :alist‘)
- Jsown Object. (‘:from :jsown‘)
- can return not only string but also octets.
- can be compiled by compiler-macro.

“‘Lisp
;; Restricted Property List Samples
(to-json ’(:name :age :born :impls))
;; => "{\"NAME\":\"AGE\",\"BORN\":\"IMPLS\"}"
;; not "[\"NAME\",\"AGE\",\"BORN\",\"IMPLS\"]"

(to-json ’(:name "Common Lisp" :born))
;; => "{\"NAME\":\"Common Lisp\",\"BORN\":[]}"
“‘

- is customizable by ‘%to-json‘, ‘%write-char‘ and ‘%write-string‘.

“‘Lisp
(defclass user ()
((id :type integer :initarg :id)
(name :type string :initarg :name)))

(defmethod %to-json ((user user))
(with-object
(write-key-value "id" (slot-value user ’id))
(write-key-value "name" (slot-value user ’name))))

(to-json (make-instance ’user :id 1 :name "Rudolph"))
;; => "{\"id\":1,\"name\":\"Rudolph\"}"
“‘

![Benchmark of to-json](./images/1.to-json.png)

“‘Lisp
(let ((post (compile-encoder () (text)
(list :|channel| "lisp-alien"
:|username| "alien-bot"
:|text| text
:|icon_url| "http://www.lisperati.com/lisplogo_warning2_256.png"))))
(time
(dotimes (_ 100000)
(funcall post "Post from Alien!"))))
;; => 0.095

(flet ((post (text)
(jonathan:to-json
(list :|channel| "lisp-alien"
:|username| "alien-bot"
:|text| text
:|icon_url| "http://www.lisperati.com/lisplogo_warning2_256.png"))))
(time
(dotimes (_ 100000)
(post "Post from Alien!"))))
;; => 0.095

(flet ((post (text)
(format nil "{\"channel\":\"lisp-alien\",\"username\":\"alien-bot\",\"text\":~s,\"icon_url\":\"http://www.lisperati.com/lisplogo_warning2_256.png\"}" text))) (time
(dotimes (_ 100000)
(post "Post from Alien!"))))"\"}"))))
;; => 0.146

(flet ((post (text)
(jonathan:to-json
(list :|channel| "lisp-alien"
:|username| "alien-bot"
:|text| text
:|icon_url| "http://www.lisperati.com/lisplogo_warning2_256.png"))))
(time
(dotimes (_ 100000)
(post "Post from Alien!"))))
;; => 0.604 - without compiler-macro.

(flet ((post (text)
(jsown:to-json
‘(:obj (:|channel| . "lisp-alien")
(:|username| . "alien-bot")
(:|text| . ,text)
(:|icon_url| . "http://www.lisperati.com/lisplogo_warning2_256.png")))))
(time
(dotimes (_ 100000)
(post "Post from Alien!"))))
;; => 1.117
“‘

## parse
- can decode JSON format string into Object.
- Property List. (‘:as :plist‘)
- Association List. (‘:as :alist‘)
- Json Object. (‘:as :jsown‘)
- Hash Table. (‘:as :hash-table‘)
- can allow junked JSON format string (‘:junk-allowed t‘)
- can customize ‘*null-value*‘, ‘*false-value*‘ and ‘*empty-array-value*‘.
- can restrict keywords to read. (‘:keywords-to-read‘)
- can normalize keywords. (‘:keyword-normalizer‘)
- can not normalize keywords in nested objects.
- can ignore keywords when normalizer returns NIL.
- can unescape unicode escape sequences. (‘:unescape-unicode-escape-sequence‘)

“‘Lisp
(parse "{\"key\":\"value\"}")
;; => (:|key| "value")

(parse "{\"key\":\"value\"")
;; => raise <jonathan-unexpected-eof>.

(parse "{\"key\":\"value\"" :junk-allowed t)
;; => (:|key| "value")

(let ((*null-value* :null)
(*false-value* :false)
(*empty-array-value* :[]))
(parse "{\"null\":null,\"false\":false,\"empty\":[]}"))
;; => (:|null| :NULL :|false| :FALSE :|empty| :[])

(parse "{\"key1\":\"value1\",\"key2\":\"value2\"}" :keywords-to-read ’("key1"))
;; => (:|key1| "value1")

(flet ((normalizer (key)
(with-vector-parsing (key)
(match-i-case
("key1" (return-from normalizer "other-key1"))
("key2" (return-from normalizer "other-key2"))
(otherwise (return-from normalizer nil))))))
(parse "{\"KEY1\":{\"key2\":\"value2\"},\"key3\":\"value3\"}"
:keyword-normalizer #’normalizer)
;; => (:|other-key1| (:|key2| "value2"))
(parse "{\"KEY1\":{\"key2\":\"value2\"},\"key3\":\"value3\"}"
:keyword-normalizer #’normalizer
:normalize-all t))
;; => (:|other-key1| (:|other-key2| "value2"))

(parse "\"\\u30b8\\u30e7\\u30ca\\u30b5\\u30f3\"")
;; => "ジョナサン"

(parse "\"\\uD840\\uDC0B\"")
;; => "𠀋"

(parse "\"\\u30b8\\u30e7\\u30ca\\u30b5\\u30f3\""
:unescape-unicode-escape-sequence nil)
;; => "\u30b8\u30e7\u30ca\u30b5\u30f3"
“‘

![Benchmark of parse](./images/2.parse.png)

“‘Lisp
(let ((s "{\"key1\":\"value\",\"key2\":1.1,\"key3\":[\"Hello\",1.2]}"))
(time
(dotimes (_ 100000)
(jonathan:parse s :as :alist))))
;; => 0.174

(let ((s "{\"key1\":\"value\",\"key2\":1.1,\"key3\":[\"Hello\",1.2]}"))
(time
(dotimes (_ 100000)
(jonathan:parse s :as :jsown))))
;; => 0.181

(let ((s "{\"key1\":\"value\",\"key2\":1.1,\"key3\":[\"Hello\",1.2]}"))
(time
(dotimes (_ 100000)
(jsown:parse s))))
;; => 0.204
“‘

![Benchmark of parse partially](./images/3.parse-partially.png)

“‘Lisp
(let ((s "{\"key1\":\"value\",\"key2\":1.1,\"key3\":[\"Hello\",1.2]}"))
(time
(dotimes (_ 100000)
(jonathan:parse s :as :alist :keywords-to-read ’("key1")))))
;; => 0.065

(let ((s "{\"key1\":\"value\",\"key2\":1.1,\"key3\":[\"Hello\",1.2]}"))
(time
(dotimes (_ 100000)
(jonathan:parse s :as :jsown :keywords-to-read ’("key1")))))
;; => 0.069

(let ((s "{\"key1\":\"value\",\"key2\":1.1,\"key3\":[\"Hello\",1.2]}"))
(time
(dotimes (_ 100000)
(jsown:parse s "key1"))))
;; => 0.085
“‘

## Helper

### compile-encoder

- can compile encoder.

“‘Lisp
(compile-encoder () (name)
(list :name name))
;; => #<FUNCTION (LAMBDA (name))>

(funcall * "Rudolph")
;; => "{\"NAME\":\"Rudolph\"}"

(compile-encoder (:from :alist) (name)
‘(("name" . ,name)))
;; => #<FUNCTION (LAMBDA (name))>

(funcall * "Rudolph")
;; => "{\"name\":\"Rudolph\"}"

(compile-encoder (:octets t) (name)
(list :name name))
;; => #<FUNCTION (LAMBDA (name))>

(funcall * "Rudolph")
;; => #(123 34 75 69 89 49 ...)
“‘

### with-object

“‘Lisp
(defclass user ()
((id :initarg :id)
(name :initarg :name)))

(defmethod %to-json ((user user))
(with-object
(write-key "id")
(write-value (slot-value user ’id))
(write-key-value "name" (slot-value user ’name))))

(to-json (make-instance ’user :id 1 :name "Rudolph"))
;; => "{\"id\":1,\"name\":\"Rudolph\"}"
“‘

### with-array

“‘Lisp
(defclass user ()
((id :initarg :id)
(name :initarg :name)))

(defmethod %to-json ((user user))
(with-array
(write-item "id")
(write-item (slot-value user ’id))
(write-item "name")
(write-item (slot-value user ’name))))

(to-json (make-instance ’user :id 1 :name "Rudolph"))
;; => "[\"id\",1,\"name\",\"Rudolph\"]"
“‘

### with-output

“‘Lisp
(with-output-to-string (stream)
(with-output (stream)
(with-object
(write-key-value "key" "value"))))
;; => "{\"key\":\"value\"}"
“‘

### with-output-to-string*

“‘Lisp
(with-output-to-string*
(with-object
(write-key-value "key" "value"))))
;; => "{\"key\":\"value\"}"
“‘

## See Also
- [proc-parse](https://github.com/fukamachi/proc-parse)

## Author

- Rudolph-Miller

## Copyright

Copyright (c) 2015 Rudolph-Miller

Version

0.1

Dependencies
  • cl-syntax (system).
  • cl-syntax-annot (system).
  • fast-io (system).
  • trivial-types (system).
  • babel (system).
  • proc-parse (system).
  • cl-ppcre (system).
  • cl-annot (system).
Source

jonathan.asd.

Child Component

src (module).


3 Modules

Modules are listed depth-first from the system components tree.


3.1 jonathan/src

Source

jonathan.asd.

Parent Component

jonathan (system).

Child Components

4 Files

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


4.1 Lisp


4.1.1 jonathan/jonathan.asd

Source

jonathan.asd.

Parent Component

jonathan (system).

ASDF Systems

jonathan.

Packages

jonathan-asd.


4.1.2 jonathan/src/jonathan.lisp

Dependencies
Source

jonathan.asd.

Parent Component

src (module).

Packages

jonathan.


4.1.3 jonathan/src/helper.lisp

Dependencies
Source

jonathan.asd.

Parent Component

src (module).

Packages

jonathan.helper.

Public Interface
Internals

4.1.4 jonathan/src/encode.lisp

Dependencies
Source

jonathan.asd.

Parent Component

src (module).

Packages

jonathan.encode.

Public Interface
Internals

4.1.5 jonathan/src/decode.lisp

Dependency

util.lisp (file).

Source

jonathan.asd.

Parent Component

src (module).

Packages

jonathan.decode.

Public Interface
Internals

4.1.6 jonathan/src/util.lisp

Dependency

error.lisp (file).

Source

jonathan.asd.

Parent Component

src (module).

Packages

jonathan.util.

Public Interface

4.1.7 jonathan/src/error.lisp

Source

jonathan.asd.

Parent Component

src (module).

Packages

jonathan.error.

Public Interface

5 Packages

Packages are listed by definition order.


5.1 jonathan.encode

Source

encode.lisp.

Use List
Used By List

jonathan.helper.

Public Interface
Internals

5.2 jonathan.helper

Source

helper.lisp.

Use List
Public Interface
Internals

5.3 jonathan

Source

jonathan.lisp.

Nickname

jojo

Use List

common-lisp.


5.4 jonathan.error

Source

error.lisp.

Use List

common-lisp.

Used By List
Public Interface

5.5 jonathan.util

Source

util.lisp.

Use List
Used By List
Public Interface

5.6 jonathan-asd

Source

jonathan.asd.

Use List
  • asdf/interface.
  • common-lisp.

5.7 jonathan.decode

Source

decode.lisp.

Use List
Public Interface
Internals

6 Definitions

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


6.1 Public Interface


6.1.1 Special variables

Special Variable: *empty-array-value*

LISP value of [].

Package

jonathan.decode.

Source

decode.lisp.

Special Variable: *empty-object-value*

LISP value of {}.

Package

jonathan.decode.

Source

decode.lisp.

Special Variable: *false-value*

LISP value of false.

Package

jonathan.decode.

Source

decode.lisp.

Special Variable: *from*

Default value of from used by #’to-json.

Package

jonathan.encode.

Source

encode.lisp.

Special Variable: *null-value*

LISP value of null.

Package

jonathan.decode.

Source

decode.lisp.

Special Variable: *octets*

Default value of octets used by #’to-json.

Package

jonathan.encode.

Source

encode.lisp.

Special Variable: *quasiquote*
Package

jonathan.util.

Source

util.lisp.

Special Variable: *stream*

Stream used by #’to-json.

Package

jonathan.encode.

Source

encode.lisp.

Special Variable: +impl-comma-p+
Package

jonathan.util.

Source

util.lisp.


6.1.2 Macros

Macro: compile-encoder ((&key octets from return-form) (&rest args) &body body)

Compile encoder.

Package

jonathan.helper.

Source

helper.lisp.

Macro: with-array (&body body)

Make writing array safe.

Package

jonathan.encode.

Source

encode.lisp.

Macro: with-object (&body body)

Make writing object safe.

Package

jonathan.encode.

Source

encode.lisp.

Macro: with-output ((stream) &body body)

Bind *stream* to stream.

Package

jonathan.encode.

Source

encode.lisp.

Macro: with-output-to-string* (&body body)

Output *stream* as string.

Package

jonathan.helper.

Source

helper.lisp.

Macro: write-item (item)

Write item of array.

Package

jonathan.encode.

Source

encode.lisp.

Macro: write-key (key)

Write key part of object.

Package

jonathan.encode.

Source

encode.lisp.

Macro: write-key-value (key value)

Write key and value of object.

Package

jonathan.encode.

Source

encode.lisp.

Macro: write-value (value)

Write value part of object.

Package

jonathan.encode.

Source

encode.lisp.


6.1.3 Compiler macros

Compiler Macro: parse (string &key as junk-allowed keywords-to-read keyword-normalizer normalize-all exclude-normalize-keys unescape-unicode-escape-sequence)
Package

jonathan.decode.

Source

decode.lisp.

Compiler Macro: to-json (args &key from octets)
Package

jonathan.encode.

Source

helper.lisp.


6.1.4 Ordinary functions

Function: %write-char (char)

Write character to *stream*.

Package

jonathan.encode.

Source

encode.lisp.

Function: %write-string (string)

Write string to *stream*.

Package

jonathan.encode.

Source

encode.lisp.

Function: comma-expr (comma)
Package

jonathan.util.

Source

util.lisp.

Function: comma-p (comma)
Package

jonathan.util.

Source

util.lisp.

Function: integer-char-p (char)
Package

jonathan.util.

Source

util.lisp.

Function: make-keyword (str)
Package

jonathan.util.

Source

util.lisp.

Function: my-plist-p (list)
Package

jonathan.util.

Source

util.lisp.

Function: parse (string &key as junk-allowed keywords-to-read keyword-normalizer normalize-all exclude-normalize-keys unescape-unicode-escape-sequence)

Convert JSON String to LISP object.

Package

jonathan.decode.

Source

decode.lisp.

Function: to-json (obj &key octets from)

Convert LISP object to JSON String.

Package

jonathan.encode.

Source

encode.lisp.


6.1.5 Generic functions

Generic Function: %to-json (obj)

Write obj as JSON string.

Package

jonathan.encode.

Source

encode.lisp.

Methods
Method: %to-json ((_ (eql nil)))
Method: %to-json ((_ (eql :empty)))
Method: %to-json ((_ (eql :null)))
Method: %to-json ((_ (eql :false)))
Method: %to-json ((_ (eql t)))
Method: %to-json ((symbol symbol))
Method: %to-json ((hash hash-table))
Method: %to-json ((vector vector))
Method: %to-json ((list list))
Method: %to-json ((ratio ratio))
Method: %to-json ((float float))
Method: %to-json ((number number))
Method: %to-json ((string string))

6.1.6 Conditions

Condition: <jonathan-error>

Base condition of jonathan-errors.

Package

jonathan.error.

Source

error.lisp.

Direct superclasses

simple-error.

Direct subclasses
Condition: <jonathan-incomplete-json-error>

Incomplete JSON string error.

Package

jonathan.error.

Source

error.lisp.

Direct superclasses

<jonathan-error>.

Direct slots
Slot: object

Parsing objcet slot.

Initargs

:object

Condition: <jonathan-not-supported-error>
Package

jonathan.error.

Source

error.lisp.

Direct superclasses

<jonathan-error>.

Direct slots
Slot: object

Not supported object slot.

Initargs

:object

Condition: <jonathan-unexpected-eof-error>

Unexpecded EOF error.

Package

jonathan.error.

Source

error.lisp.

Direct superclasses

<jonathan-error>.

Direct slots
Slot: object

Parsing object slot.

Initargs

:object

Condition: <jonathan-without-tail-surrogate-error>
Package

jonathan.error.

Source

error.lisp.

Direct superclasses

<jonathan-error>.


6.2 Internals


6.2.1 Special variables

Special Variable: *compile-encoder-prefix*
Package

jonathan.helper.

Source

helper.lisp.

Special Variable: *inner-nest-p*
Package

jonathan.decode.

Source

decode.lisp.


6.2.2 Macros

Macro: make-normalizer (keywords)
Package

jonathan.decode.

Source

decode.lisp.

Macro: with-macro-p (list)
Package

jonathan.encode.

Source

encode.lisp.


6.2.3 Ordinary functions

Function: alist-to-json (list)
Package

jonathan.encode.

Source

encode.lisp.

Function: check-args (args)
Package

jonathan.helper.

Source

helper.lisp.

Function: foldable-keywords-to-read-p (keywords-to-read)
Package

jonathan.decode.

Source

decode.lisp.

Function: list-to-json (list)
Package

jonathan.encode.

Source

encode.lisp.

Function: normalize-form (object)
Package

jonathan.helper.

Source

helper.lisp.

Function: plist-to-json (list)
Package

jonathan.encode.

Source

encode.lisp.

Function: replace-form-with-placeholders (form)
Package

jonathan.helper.

Source

helper.lisp.

Function: string-to-json (string)
Package

jonathan.encode.

Source

encode.lisp.


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   %  
A   C   F   G   I   L   M   N   P   R   S   T   W  
Index Entry  Section

%
%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
%write-char: Public ordinary functions
%write-string: Public ordinary functions

A
alist-to-json: Private ordinary functions

C
check-args: Private ordinary functions
comma-expr: Public ordinary functions
comma-p: Public ordinary functions
compile-encoder: Public macros
Compiler Macro, parse: Public compiler macros
Compiler Macro, to-json: Public compiler macros

F
foldable-keywords-to-read-p: Private ordinary functions
Function, %write-char: Public ordinary functions
Function, %write-string: Public ordinary functions
Function, alist-to-json: Private ordinary functions
Function, check-args: Private ordinary functions
Function, comma-expr: Public ordinary functions
Function, comma-p: Public ordinary functions
Function, foldable-keywords-to-read-p: Private ordinary functions
Function, integer-char-p: Public ordinary functions
Function, list-to-json: Private ordinary functions
Function, make-keyword: Public ordinary functions
Function, my-plist-p: Public ordinary functions
Function, normalize-form: Private ordinary functions
Function, parse: Public ordinary functions
Function, plist-to-json: Private ordinary functions
Function, replace-form-with-placeholders: Private ordinary functions
Function, string-to-json: Private ordinary functions
Function, to-json: Public ordinary functions

G
Generic Function, %to-json: Public generic functions

I
integer-char-p: Public ordinary functions

L
list-to-json: Private ordinary functions

M
Macro, compile-encoder: Public macros
Macro, make-normalizer: Private macros
Macro, with-array: Public macros
Macro, with-macro-p: Private macros
Macro, with-object: Public macros
Macro, with-output: Public macros
Macro, with-output-to-string*: Public macros
Macro, write-item: Public macros
Macro, write-key: Public macros
Macro, write-key-value: Public macros
Macro, write-value: Public macros
make-keyword: Public ordinary functions
make-normalizer: Private macros
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
my-plist-p: Public ordinary functions

N
normalize-form: Private ordinary functions

P
parse: Public compiler macros
parse: Public ordinary functions
plist-to-json: Private ordinary functions

R
replace-form-with-placeholders: Private ordinary functions

S
string-to-json: Private ordinary functions

T
to-json: Public compiler macros
to-json: Public ordinary functions

W
with-array: Public macros
with-macro-p: Private macros
with-object: Public macros
with-output: Public macros
with-output-to-string*: Public macros
write-item: Public macros
write-key: Public macros
write-key-value: Public macros
write-value: Public macros


A.4 Data types

Jump to:   <  
C   D   E   F   H   J   M   P   S   U  
Index Entry  Section

<
<jonathan-error>: Public conditions
<jonathan-incomplete-json-error>: Public conditions
<jonathan-not-supported-error>: Public conditions
<jonathan-unexpected-eof-error>: Public conditions
<jonathan-without-tail-surrogate-error>: Public conditions

C
Condition, <jonathan-error>: Public conditions
Condition, <jonathan-incomplete-json-error>: Public conditions
Condition, <jonathan-not-supported-error>: Public conditions
Condition, <jonathan-unexpected-eof-error>: Public conditions
Condition, <jonathan-without-tail-surrogate-error>: Public conditions

D
decode.lisp: The jonathan/src/decode․lisp file

E
encode.lisp: The jonathan/src/encode․lisp file
error.lisp: The jonathan/src/error․lisp file

F
File, decode.lisp: The jonathan/src/decode․lisp file
File, encode.lisp: The jonathan/src/encode․lisp file
File, error.lisp: The jonathan/src/error․lisp file
File, helper.lisp: The jonathan/src/helper․lisp file
File, jonathan.asd: The jonathan/jonathan․asd file
File, jonathan.lisp: The jonathan/src/jonathan․lisp file
File, util.lisp: The jonathan/src/util․lisp file

H
helper.lisp: The jonathan/src/helper․lisp file

J
jonathan: The jonathan system
jonathan: The jonathan package
jonathan-asd: The jonathan-asd package
jonathan.asd: The jonathan/jonathan․asd file
jonathan.decode: The jonathan․decode package
jonathan.encode: The jonathan․encode package
jonathan.error: The jonathan․error package
jonathan.helper: The jonathan․helper package
jonathan.lisp: The jonathan/src/jonathan․lisp file
jonathan.util: The jonathan․util package

M
Module, src: The jonathan/src module

P
Package, jonathan: The jonathan package
Package, jonathan-asd: The jonathan-asd package
Package, jonathan.decode: The jonathan․decode package
Package, jonathan.encode: The jonathan․encode package
Package, jonathan.error: The jonathan․error package
Package, jonathan.helper: The jonathan․helper package
Package, jonathan.util: The jonathan․util package

S
src: The jonathan/src module
System, jonathan: The jonathan system

U
util.lisp: The jonathan/src/util․lisp file