The trivial-string-template Reference Manual

Table of Contents

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

The trivial-string-template Reference Manual

This is the trivial-string-template Reference Manual, version 0.1, generated automatically by Declt version 2.3 "Robert April" on Wed Mar 14 04:41:30 2018 GMT+0.


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

1 Introduction

#+TITLE: Trivial-String-Template
#+AUTHOR: David Gu
#+DATE: <2016-04-11 Mon>
#+EMAIL: macdavid313@gmail.com

#+begin_html
Travis-CI Status
Coverage Status

#+end_html

A trivial string template library, inspired by Python's string.Template; you can check around the Python's functionality [[https://docs.python.org/2/library/string.html?highlight=string.template#string.Template][here]].

* Usage

** substitute

#+begin_src lisp
(substitute "$who likes $what" :who "tim" :what "kung pao")
;; => "tim likes kung pao"
#+end_src

You can specify the `delimiter` character by lexcially binding the special variable `\*delimiter\*`:

#+begin_src lisp
(let ((*delimiter* #\%))
  (substitute "%who likes %what" :who "tim" :what "kung pao"))
;; => "tim likes kung pao"
#+end_src

You can escape a `delimiter` character:

#+begin_src lisp
(substitute "Give $who $$100" :who "tim")
;; => "Give tim $100"
#+end_src

And you can use '{}' to set a so called `placeholder`:

#+begin_src lisp
(substitute "$who likes ${what}--is it for real?" :who "tim" :what "kung pao")
;; => "tim likes kung pao--is it for real?"
#+end_src

** safe-substitute

#+begin_src lisp
(safe-substitute "$who likes $what" :what "kung pao")
;; => "$who likes kung pao"
#+end_src

** template

It will produce a template class, which is funcallable. Some accessors methods are exported, by which you can modify the state of a template and don't you worry about any confilcts because every accessor will automatically adjust and then make itself consistent.

#+begin_src lisp
(defvar *tmpl* (template "$who likes $what"))
(funcall *tmpl* :who "a" :what "b")
;; => "a likes b"
(setf (source-string *tmpl*) "Give $who $$100")
(funcall *tmpl* :who "me")
;; => "Give me $100"
#+end_src

** define-template

Just a wrapper around template class.

#+begin_src lisp
(define-template tmpl (:delimiter #\& :safe t) "&who likes &what")
;; => #
(tmpl :who tim) ;; => "tim likes &what"
#+end_src

* TODO TO DO List [66%]
  - [X] Provide a more detailed APIs documenatation.
  - [X] More tests.
  - [ ] Improvements.

* Author

- David Gu (macdavid313@gmail.com)

* License

Licensed under the MIT License.


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 trivial-string-template

Author

David Gu

License

MIT

Description

A trivial string template library, inspired by Python’s string.Template

Long Description

#+TITLE: Trivial-String-Template
#+AUTHOR: David Gu
#+DATE: <2016-04-11 Mon>
#+EMAIL: macdavid313@gmail.com

#+begin_html
<a href="https://travis-ci.org/macdavid313/trivial-string-template"><img src="https://travis-ci.org/macdavid313/trivial-string-template.svg?branch=master" alt="Travis-CI Status" /></a>
<a href="https://coveralls.io/github/macdavid313/trivial-string-template?branch=master"><img src="https://coveralls.io/repos/github/macdavid313/trivial-string-template/badge.svg?branch=master" alt="Coverage Status" /></a>
<a href="http://quickdocs.org/trivial-string-template"><img src="http://quickdocs.org/badge/trivial-string-template.svg" /></a>
#+end_html

A trivial string template library, inspired by Python’s string.Template; you can check around the Python’s functionality [[https://docs.python.org/2/library/string.html?highlight=string.template#string.Template][here]].

* Usage

** substitute

#+begin_src lisp
(substitute "$who likes $what" :who "tim" :what "kung pao")
;; => "tim likes kung pao"
#+end_src

You can specify the ‘delimiter‘ character by lexcially binding the special variable ‘\*delimiter\*‘:

#+begin_src lisp
(let ((*delimiter* #\%))
(substitute "%who likes %what" :who "tim" :what "kung pao"))
;; => "tim likes kung pao"
#+end_src

You can escape a ‘delimiter‘ character:

#+begin_src lisp
(substitute "Give $who $$100" :who "tim")
;; => "Give tim $100"
#+end_src

And you can use ’{}’ to set a so called ‘placeholder‘:

#+begin_src lisp
(substitute "$who likes ${what}–is it for real?" :who "tim" :what "kung pao")
;; => "tim likes kung pao–is it for real?"
#+end_src

** safe-substitute

#+begin_src lisp
(safe-substitute "$who likes $what" :what "kung pao")
;; => "$who likes kung pao"
#+end_src

** template

It will produce a template class, which is funcallable. Some accessors methods are exported, by which you can modify the state of a template and don’t you worry about any confilcts because every accessor will automatically adjust and then make itself consistent.

#+begin_src lisp
(defvar *tmpl* (template "$who likes $what"))
(funcall *tmpl* :who "a" :what "b")
;; => "a likes b"
(setf (source-string *tmpl*) "Give $who $$100")
(funcall *tmpl* :who "me")
;; => "Give me $100"
#+end_src

** define-template

Just a wrapper around template class.

#+begin_src lisp
(define-template tmpl (:delimiter #\& :safe t) "&who likes &what")
;; => #<TRIVIAL-STRING-TEMPLATE:TEMPLATE {1003B1FC7B}>
(tmpl :who tim) ;; => "tim likes &what"
#+end_src

* TODO TO DO List [66%]
- [X] Provide a more detailed APIs documenatation.
- [X] More tests.
- [ ] Improvements.

* Author

- David Gu (macdavid313@gmail.com)

* License

Licensed under the MIT License.

Version

0.1

Dependencies
Source

trivial-string-template.asd (file)

Component

src (module)


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

3 Modules

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


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

3.1 trivial-string-template/src

Parent

trivial-string-template (system)

Location

src/

Component

trivial-string-template.lisp (file)


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

4 Files

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


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

4.1 Lisp


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

4.1.1 trivial-string-template.asd

Location

trivial-string-template.asd

Systems

trivial-string-template (system)

Packages

trivial-string-template-asd


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

4.1.2 trivial-string-template/src/trivial-string-template.lisp

Parent

src (module)

Location

src/trivial-string-template.lisp

Packages

trivial-string-template

Exported Definitions
Internal Definitions

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

5 Packages

Packages are listed by definition order.


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

5.1 trivial-string-template-asd

Source

trivial-string-template.asd

Use List

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

5.2 trivial-string-template

Source

trivial-string-template.lisp (file)

Nicknames
Use List
Exported Definitions
Internal Definitions

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

6 Definitions

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


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

6.1 Exported definitions


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

6.1.1 Special variables

Special Variable: *delimiter*

Default delimiter character.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Special Variable: *tokenizer*

A default tokenizer will be used during parsing the template strings.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Special Variable: *variable-pattern*

Default variable pattern

Package

trivial-string-template

Source

trivial-string-template.lisp (file)


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

6.1.2 Macros

Macro: define-template VAR (&key DELIMITER VARIABLE-PATTERN SAFE TOKENIZER) TEMPLATE

Given the template string and thoses parameters, set the function definition of the symbol ‘var’.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)


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

6.1.3 Compiler macros

Compiler Macro: safe-substitute TEMPLATE &rest ARGS &key &allow-other-keys
Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Compiler Macro: substitute TEMPLATE &rest ARGS &key &allow-other-keys
Package

trivial-string-template

Source

trivial-string-template.lisp (file)


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

6.1.4 Functions

Function: make-tokenizer &key REGEX SEPARATORS

Construction function for ‘%tokenizer%’ class.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Function: reset-template TEMPLATE SOURCE-STRING &key DELIMITER VARIABLE-PATTERN TOKENIZER SAFE

Reset several slots and re-parse the template itself.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Function: safe-substitute TEMPLATE &rest ARGS &key &allow-other-keys

Given a template string and the variables(as keywords) it requires, return the formatted string; compared to ‘substitute’, this function won’t issue an error when there’s missing variable information but uses the variable’s name as a default value.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Function: substitute TEMPLATE &rest ARGS &key &allow-other-keys

Given a template string and the variables(as keywords) it requires, return the formatted string; if there’s missing variable information, it will issue an error.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Function: template TEMPLATE &key DELIMITER VARIABLE-PATTERN SAFE TOKENIZER

Constructor method for template class.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)


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

6.1.5 Generic functions

Generic Function: add-separator TOKENIZER SEPARATOR
Package

trivial-string-template

Methods
Method: add-separator (THIS template) SEPARATOR
Source

trivial-string-template.lisp (file)

Method: add-separator (TOKENIZER %tokenizer%) SEPARATOR
Source

trivial-string-template.lisp (file)

Generic Function: add-separators TOKENIZER &rest SEPARATORS
Package

trivial-string-template

Methods
Method: add-separators (THIS template) &rest SEPARATORS
Source

trivial-string-template.lisp (file)

Method: add-separators (TOKENIZER %tokenizer%) &rest SEPARATORS
Source

trivial-string-template.lisp (file)

Generic Function: delete-separator TOKENIZER SEPARATOR
Package

trivial-string-template

Methods
Method: delete-separator (THIS template) SEPARATOR
Source

trivial-string-template.lisp (file)

Method: delete-separator (TOKENIZER %tokenizer%) SEPARATOR
Source

trivial-string-template.lisp (file)

Generic Function: delete-separators TOKENIZER &rest SEPARATORS
Package

trivial-string-template

Methods
Method: delete-separators (THIS template) &rest SEPARATORS
Source

trivial-string-template.lisp (file)

Method: delete-separators (TOKENIZER %tokenizer%) &rest SEPARATORS
Source

trivial-string-template.lisp (file)

Generic Function: delimiter OBJECT
Generic Function: (setf delimiter) NEW-VALUE OBJECT
Package

trivial-string-template

Methods
Method: delimiter (TEMPLATE template)

automatically generated reader method

Source

trivial-string-template.lisp (file)

Method: (setf delimiter) NEW-VALUE (TEMPLATE template)

automatically generated writer method

Source

trivial-string-template.lisp (file)

Method: (setf delimiter) (NEW character) (THIS template) after
Source

trivial-string-template.lisp (file)

Method: (setf delimiter) (NEW character) (THIS template) around
Source

trivial-string-template.lisp (file)

Generic Function: safe OBJECT
Generic Function: (setf safe) NEW-VALUE OBJECT
Package

trivial-string-template

Methods
Method: safe (TEMPLATE template)

automatically generated reader method

Source

trivial-string-template.lisp (file)

Method: (setf safe) NEW-VALUE (TEMPLATE template)

automatically generated writer method

Source

trivial-string-template.lisp (file)

Method: (setf safe) (NEW symbol) (THIS template) after
Source

trivial-string-template.lisp (file)

Method: (setf safe) (NEW symbol) (THIS template) around
Source

trivial-string-template.lisp (file)

Generic Function: source-string OBJECT
Generic Function: (setf source-string) NEW-VALUE OBJECT
Package

trivial-string-template

Methods
Method: source-string (TEMPLATE template)

automatically generated reader method

Source

trivial-string-template.lisp (file)

Method: (setf source-string) NEW-VALUE (TEMPLATE template)

automatically generated writer method

Source

trivial-string-template.lisp (file)

Method: (setf source-string) (NEW string) (THIS template) after
Source

trivial-string-template.lisp (file)

Method: (setf source-string) (NEW string) (THIS template) around
Source

trivial-string-template.lisp (file)

Generic Function: template-tokenizer OBJECT
Generic Function: (setf template-tokenizer) NEW-VALUE OBJECT
Package

trivial-string-template

Methods
Method: template-tokenizer (TEMPLATE template)

automatically generated reader method

Source

trivial-string-template.lisp (file)

Method: (setf template-tokenizer) NEW-VALUE (TEMPLATE template)

automatically generated writer method

Source

trivial-string-template.lisp (file)

Method: (setf template-tokenizer) (NEW %tokenizer%) (THIS template) after
Source

trivial-string-template.lisp (file)

Method: (setf template-tokenizer) (NEW %tokenizer%) (THIS template) around
Source

trivial-string-template.lisp (file)

Generic Function: tokenizer-regex OBJECT
Generic Function: (setf tokenizer-regex) NEW-VALUE OBJECT
Package

trivial-string-template

Methods
Method: tokenizer-regex (%TOKENIZER% %tokenizer%)

automatically generated reader method

Source

trivial-string-template.lisp (file)

Method: (setf tokenizer-regex) NEW-VALUE (%TOKENIZER% %tokenizer%)

automatically generated writer method

Source

trivial-string-template.lisp (file)

Method: (setf tokenizer-regex) (NEW string) (THIS %tokenizer%) after
Source

trivial-string-template.lisp (file)

Method: (setf tokenizer-regex) (NEW string) (THIS %tokenizer%) before
Source

trivial-string-template.lisp (file)

Generic Function: tokenizer-separators OBJECT
Generic Function: (setf tokenizer-separators) NEW-VALUE OBJECT
Package

trivial-string-template

Methods
Method: tokenizer-separators (%TOKENIZER% %tokenizer%)

automatically generated reader method

Source

trivial-string-template.lisp (file)

Method: (setf tokenizer-separators) NEW-VALUE (%TOKENIZER% %tokenizer%)

automatically generated writer method

Source

trivial-string-template.lisp (file)

Generic Function: variable-pattern OBJECT
Generic Function: (setf variable-pattern) NEW-VALUE OBJECT
Package

trivial-string-template

Methods
Method: variable-pattern (TEMPLATE template)

automatically generated reader method

Source

trivial-string-template.lisp (file)

Method: (setf variable-pattern) NEW-VALUE (TEMPLATE template)

automatically generated writer method

Source

trivial-string-template.lisp (file)

Method: (setf variable-pattern) (NEW string) (THIS template) after
Source

trivial-string-template.lisp (file)

Method: (setf variable-pattern) (NEW string) (THIS template) around
Source

trivial-string-template.lisp (file)


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

6.1.6 Classes

Class: template ()

The definition of Template class. Unlike ‘substitute’ and ‘safe-substitute’, it is a high-level API.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Direct superclasses

funcallable-standard-object (class)

Direct methods
Direct slots
Slot: delimiter
Type

character

Initargs

:delimiter

Readers

delimiter (generic function)

Writers

(setf delimiter) (generic function)

Slot: variable-pattern
Type

function

Initargs

:variable-pattern

Readers

variable-pattern (generic function)

Writers

(setf variable-pattern) (generic function)

Slot: source
Type

simple-string

Initargs

:template-source

Readers

source-string (generic function)

Writers

(setf source-string) (generic function)

Slot: safe
Type

symbol

Initargs

:safe

Readers

safe (generic function)

Writers

(setf safe) (generic function)

Slot: tokenizer
Type

trivial-string-template::%tokenizer%

Initargs

:tokenizer

Readers

template-tokenizer (generic function)

Writers

(setf template-tokenizer) (generic function)

Slot: datum
Type

simple-string

Initargs

:template-datum

Slot: variables
Type

(array simple-string (*))

Initargs

:template-variables


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

6.2 Internal definitions


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

6.2.1 Constants

Constant: +empty-string+

Just an empty string.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Constant: +left-brace+

The left brace character.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Constant: +lisp-common-pattern+

Regular expression pattern for a regular Common Lisp identifier, e.g. ‘variable-information’, ‘define-symbol-macro’, etc.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Constant: +python-pattern+

Regular expression pattern for a valid python identifier.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Constant: +right-brace+

The right brace character.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)


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

6.2.2 Special variables

Special Variable: %segments%

A vector that stores segments information for a string template,
e.g. "$who likes $me." => #((:VARIABLE "who") " likes " (:VARIABLE "me") "."); It will be reused over and over again.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Special Variable: %variables%

A vector that stores variables names for a string template, e.g. "$who likes $me." => #("who" "me");
It will be reused over and over again.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)


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

6.2.3 Symbol macros

Symbol Macro: .to-symbol.
Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Expansion

(case (readtable-case *readtable*) (:preserve (quote intern)) (t (lambda (trivial-string-template::str) (intern (string-upcase trivial-string-template::str)))))


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

6.2.4 Compiler macros

Compiler Macro: variable-pattern-matched-p VARIABLE-NAME VARIABLE-PATTERN
Package

trivial-string-template

Source

trivial-string-template.lisp (file)


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

6.2.5 Functions

Function: append-supplied-p NAME

Depending on the ‘(readtable-case *readtable*)’, when given a ‘name’ string, prefix it with "-SUPPLIED-P" or "-supplied-p".

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Function: collect-format-arguments ARGS VARIABLES &key SAFE

Prepare arguments for the ‘format’ function.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Function: make-template-datum SEGMENTS

Given the segments vector, produce the control string for ‘format’ function.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Function: make-template-function DATUM VARIABLES DELIMITER &key SAFE

Given its datum, variables, delimiter and probably the safe, make a compiled function for a template.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Function: make-template-parameters-list VARIABLES DELIMITER SAFE

Helper function for ‘make-template-function’, it helps generate the corresponding parameters list.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Function: make-tokenizer-function COMPILED-RE SEPARATORS

Given a compiled regular expression, and a list of separators characters, produce a predicating function that when given a character, it tells whether it’s a separator.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Function: parse-template ()

The essential parsing function.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Function: reparse-template TEMPLATE

Re-parse a template with its own slots;
this function will be issued when one of slot is modified.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Function: variable-pattern-matched-p VARIABLE-NAME VARIABLE-PATTERN

Validate whether a variable’s name is matched by the pattern.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)


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

6.2.6 Classes

Class: %tokenizer% ()

A class used for managing the way of how to recognize separators during parsing a template string.

Package

trivial-string-template

Source

trivial-string-template.lisp (file)

Direct superclasses

funcallable-standard-object (class)

Direct methods
Direct slots
Slot: regex
Type

simple-string

Initargs

:regex

Readers

tokenizer-regex (generic function)

Writers

(setf tokenizer-regex) (generic function)

Slot: compiled-re
Slot: separators
Type

list

Initargs

:separators

Readers

tokenizer-separators (generic function)

Writers

(setf tokenizer-separators) (generic function)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L   M   T  
Index Entry  Section

F
File, Lisp, trivial-string-template.asd: The trivial-string-template<dot>asd file
File, Lisp, trivial-string-template/src/trivial-string-template.lisp: The trivial-string-template/src/trivial-string-template<dot>lisp file

L
Lisp File, trivial-string-template.asd: The trivial-string-template<dot>asd file
Lisp File, trivial-string-template/src/trivial-string-template.lisp: The trivial-string-template/src/trivial-string-template<dot>lisp file

M
Module, trivial-string-template/src: The trivial-string-template/src module

T
trivial-string-template.asd: The trivial-string-template<dot>asd file
trivial-string-template/src: The trivial-string-template/src module
trivial-string-template/src/trivial-string-template.lisp: The trivial-string-template/src/trivial-string-template<dot>lisp file

Jump to:   F   L   M   T  

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

A.2 Functions

Jump to:   (  
A   C   D   F   G   M   P   R   S   T   V  
Index Entry  Section

(
(setf delimiter): Exported generic functions
(setf delimiter): Exported generic functions
(setf delimiter): Exported generic functions
(setf delimiter): Exported generic functions
(setf safe): Exported generic functions
(setf safe): Exported generic functions
(setf safe): Exported generic functions
(setf safe): Exported generic functions
(setf source-string): Exported generic functions
(setf source-string): Exported generic functions
(setf source-string): Exported generic functions
(setf source-string): Exported generic functions
(setf template-tokenizer): Exported generic functions
(setf template-tokenizer): Exported generic functions
(setf template-tokenizer): Exported generic functions
(setf template-tokenizer): Exported generic functions
(setf tokenizer-regex): Exported generic functions
(setf tokenizer-regex): Exported generic functions
(setf tokenizer-regex): Exported generic functions
(setf tokenizer-regex): Exported generic functions
(setf tokenizer-separators): Exported generic functions
(setf tokenizer-separators): Exported generic functions
(setf variable-pattern): Exported generic functions
(setf variable-pattern): Exported generic functions
(setf variable-pattern): Exported generic functions
(setf variable-pattern): Exported generic functions

A
add-separator: Exported generic functions
add-separator: Exported generic functions
add-separator: Exported generic functions
add-separators: Exported generic functions
add-separators: Exported generic functions
add-separators: Exported generic functions
append-supplied-p: Internal functions

C
collect-format-arguments: Internal functions
Compiler Macro, safe-substitute: Exported compiler macros
Compiler Macro, substitute: Exported compiler macros
Compiler Macro, variable-pattern-matched-p: Internal compiler macros

D
define-template: Exported macros
delete-separator: Exported generic functions
delete-separator: Exported generic functions
delete-separator: Exported generic functions
delete-separators: Exported generic functions
delete-separators: Exported generic functions
delete-separators: Exported generic functions
delimiter: Exported generic functions
delimiter: Exported generic functions

F
Function, append-supplied-p: Internal functions
Function, collect-format-arguments: Internal functions
Function, make-template-datum: Internal functions
Function, make-template-function: Internal functions
Function, make-template-parameters-list: Internal functions
Function, make-tokenizer: Exported functions
Function, make-tokenizer-function: Internal functions
Function, parse-template: Internal functions
Function, reparse-template: Internal functions
Function, reset-template: Exported functions
Function, safe-substitute: Exported functions
Function, substitute: Exported functions
Function, template: Exported functions
Function, variable-pattern-matched-p: Internal functions

G
Generic Function, (setf delimiter): Exported generic functions
Generic Function, (setf safe): Exported generic functions
Generic Function, (setf source-string): Exported generic functions
Generic Function, (setf template-tokenizer): Exported generic functions
Generic Function, (setf tokenizer-regex): Exported generic functions
Generic Function, (setf tokenizer-separators): Exported generic functions
Generic Function, (setf variable-pattern): Exported generic functions
Generic Function, add-separator: Exported generic functions
Generic Function, add-separators: Exported generic functions
Generic Function, delete-separator: Exported generic functions
Generic Function, delete-separators: Exported generic functions
Generic Function, delimiter: Exported generic functions
Generic Function, safe: Exported generic functions
Generic Function, source-string: Exported generic functions
Generic Function, template-tokenizer: Exported generic functions
Generic Function, tokenizer-regex: Exported generic functions
Generic Function, tokenizer-separators: Exported generic functions
Generic Function, variable-pattern: Exported generic functions

M
Macro, define-template: Exported macros
make-template-datum: Internal functions
make-template-function: Internal functions
make-template-parameters-list: Internal functions
make-tokenizer: Exported functions
make-tokenizer-function: Internal functions
Method, (setf delimiter): Exported generic functions
Method, (setf delimiter): Exported generic functions
Method, (setf delimiter): Exported generic functions
Method, (setf safe): Exported generic functions
Method, (setf safe): Exported generic functions
Method, (setf safe): Exported generic functions
Method, (setf source-string): Exported generic functions
Method, (setf source-string): Exported generic functions
Method, (setf source-string): Exported generic functions
Method, (setf template-tokenizer): Exported generic functions
Method, (setf template-tokenizer): Exported generic functions
Method, (setf template-tokenizer): Exported generic functions
Method, (setf tokenizer-regex): Exported generic functions
Method, (setf tokenizer-regex): Exported generic functions
Method, (setf tokenizer-regex): Exported generic functions
Method, (setf tokenizer-separators): Exported generic functions
Method, (setf variable-pattern): Exported generic functions
Method, (setf variable-pattern): Exported generic functions
Method, (setf variable-pattern): Exported generic functions
Method, add-separator: Exported generic functions
Method, add-separator: Exported generic functions
Method, add-separators: Exported generic functions
Method, add-separators: Exported generic functions
Method, delete-separator: Exported generic functions
Method, delete-separator: Exported generic functions
Method, delete-separators: Exported generic functions
Method, delete-separators: Exported generic functions
Method, delimiter: Exported generic functions
Method, safe: Exported generic functions
Method, source-string: Exported generic functions
Method, template-tokenizer: Exported generic functions
Method, tokenizer-regex: Exported generic functions
Method, tokenizer-separators: Exported generic functions
Method, variable-pattern: Exported generic functions

P
parse-template: Internal functions

R
reparse-template: Internal functions
reset-template: Exported functions

S
safe: Exported generic functions
safe: Exported generic functions
safe-substitute: Exported compiler macros
safe-substitute: Exported functions
source-string: Exported generic functions
source-string: Exported generic functions
substitute: Exported compiler macros
substitute: Exported functions

T
template: Exported functions
template-tokenizer: Exported generic functions
template-tokenizer: Exported generic functions
tokenizer-regex: Exported generic functions
tokenizer-regex: Exported generic functions
tokenizer-separators: Exported generic functions
tokenizer-separators: Exported generic functions

V
variable-pattern: Exported generic functions
variable-pattern: Exported generic functions
variable-pattern-matched-p: Internal compiler macros
variable-pattern-matched-p: Internal functions

Jump to:   (  
A   C   D   F   G   M   P   R   S   T   V  

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

A.3 Variables

Jump to:   %   *   +   .  
C   D   R   S   T   V  
Index Entry  Section

%
%segments%: Internal special variables
%variables%: Internal special variables

*
*delimiter*: Exported special variables
*tokenizer*: Exported special variables
*variable-pattern*: Exported special variables

+
+empty-string+: Internal constants
+left-brace+: Internal constants
+lisp-common-pattern+: Internal constants
+python-pattern+: Internal constants
+right-brace+: Internal constants

.
.to-symbol.: Internal symbol macros

C
compiled-re: Internal classes
Constant, +empty-string+: Internal constants
Constant, +left-brace+: Internal constants
Constant, +lisp-common-pattern+: Internal constants
Constant, +python-pattern+: Internal constants
Constant, +right-brace+: Internal constants

D
datum: Exported classes
delimiter: Exported classes

R
regex: Internal classes

S
safe: Exported classes
separators: Internal classes
Slot, compiled-re: Internal classes
Slot, datum: Exported classes
Slot, delimiter: Exported classes
Slot, regex: Internal classes
Slot, safe: Exported classes
Slot, separators: Internal classes
Slot, source: Exported classes
Slot, tokenizer: Exported classes
Slot, variable-pattern: Exported classes
Slot, variables: Exported classes
source: Exported classes
Special Variable, %segments%: Internal special variables
Special Variable, %variables%: Internal special variables
Special Variable, *delimiter*: Exported special variables
Special Variable, *tokenizer*: Exported special variables
Special Variable, *variable-pattern*: Exported special variables
Symbol Macro, .to-symbol.: Internal symbol macros

T
tokenizer: Exported classes

V
variable-pattern: Exported classes
variables: Exported classes

Jump to:   %   *   +   .  
C   D   R   S   T   V  

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

A.4 Data types

Jump to:   %  
C   P   S   T  
Index Entry  Section

%
%tokenizer%: Internal classes

C
Class, %tokenizer%: Internal classes
Class, template: Exported classes

P
Package, trivial-string-template: The trivial-string-template package
Package, trivial-string-template-asd: The trivial-string-template-asd package

S
System, trivial-string-template: The trivial-string-template system

T
template: Exported classes
trivial-string-template: The trivial-string-template system
trivial-string-template: The trivial-string-template package
trivial-string-template-asd: The trivial-string-template-asd package

Jump to:   %  
C   P   S   T