Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
The ten Reference Manual
This is the ten Reference Manual, version 0.0.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed Jun 15 05:58:11 2022 GMT+0.
Table of Contents
Next: Systems, Previous: The ten Reference Manual, Up: The ten Reference Manual [Contents][Index]
1 Introduction
TEN
Yet another template system for Common Lisp.
TEN is a fork of ECO template system by Fernando Borretti.
Like ECO, TEN compiles templates to Lisp code, but has some differences:
- Two types of tags only. Control and output.
- Support for templates inheritance.
- Dot syntax for accessing template data.
- Convenient syntax for applying filters.
- Configurable syntax delimiters (planned, not done yet).
My reasons for writing yet another template system for Common Lisp is to combine the simplicity and usability of ECO (the whole Lisp language at your disposal for writing the templates), with features available in more complex template systems like Djula that makes things easier for web development (inheritance, dot syntax, etc.).
Usage
A TEN template looks like this:
{% template ex1 () (user enabled &key items) %}
<html>
<head>
</head>
<body>
{{ user.name | string-capitalize }}
{% if enabled %}
Enabled
{% else %}
Disabled
{% end %}
{% when items %}
<ul>
{% loop for item in items do %}
<li>{{ item }}</li>
{% end %}
</ul>
{% end %}
{% when (not items) %}
There are no items
{% end %}
</body>
</html>
{% end %}
These are the types of tags:
- Output tags:
{{ <var> }}, becomes<var>, and{{ <fn> &rest args }}, that becomes(fn arg1 arg2 .. argn). - Control tags:
{% <expr> %} body {% end %}, becomes(<expr> body). - Comments tags: Use
{#and#}to comment out a piece of template.
Control tags control which parts of the tamplate are rendered; their return value is ignored.
The value returned by output tags are interpolated into the template. The function called can be any Lisp function, or another template (because templates are compiled to functions).
For example:
{{ user }}=>user{{ name user }}=>(name user){% when (name user) %} ... {% end %}=>(when (name user) ...)
The if tag is a special case: it supports using an else tag to separate the true and
false branches. For example:
{% if posts %}
<h1>Recent Posts</h1>
... loop over posts ...
{% else %}
No recent posts.
{% end %}
Also, more advanced control expressions are possible, like let, case, cond, etc.
Template definition
Templates are defined with the following syntax:
{% template name (&rest options) (&rest args) %}
... body ...
{% end %}
Template options are:
:extends: The template to extend from.:dot-syntax: If T, templates are compiled with dot syntax enabled. Dot syntax is implemented via the Lisp libraryaccess. Default is T.:package: The package in which to compile and export the template. By default, templates are compiled and exported inTEN-TEMPLATESpackage.:export: When T, export the generated template function. Otherwise, the template is not exported. Default is T.:escape-html: Whether to escape html in output tags. Default is T.:output-whitespace. Default is T. When NIL, expressions that just spit whitespace are discarded.
Template compilation
For manually compiling templates, use ten:compile-template function.
But more useful is to include them in the ASDF system definition of your project.
First, add :ten as ASDF system definition dependency:
:defsystem-depends-on (:ten)
Then, use :ten-template in to include the template files:
(:ten-template "filename")
The default file extension is "ten", but another can be specified via the :file-extension option; and the template package can be specified with the :package option. Look at ten.examples ASDF system for an example.
You can also compile all the templates in some directory using this ASDF recipe:
:perform (asdf:compile-op :after (o c)
(dolist (template (uiop:directory-files (asdf:system-relative-pathname :my-app "templates/*.ten")))
(uiop:symbol-call :ten 'compile-template template)))
Templates are compiled into functions and exported in the indicated package. The default package is ten-templates, but that can be changed from either the ASDF system definition, the ten:compile-template parameters, or the {% template %} options.
When developing your project it is useful to be able to compile templates in an interactive way.
If you are using Emacs + SLIME, load ten.el file.
Then use M-X ten-compile-template when on the template buffer to compile templates. Note that you may want to have :package option specified in the template so that it gets compiled into the correct package.
For debugging, you can inspect the expanded template using ten:expand-template function. In Emacs, go to template buffer an do M-x ten-expand-template.
If you enable ten minor mode, template compilation gets conveniently bound to C-c C-c, and template expansion to C-c RET. Best is to automatically enable the minor mode for template files adding something like (add-hook 'web-mode-hook 'ten-mode) to your .emacs initialization file.
Inheritance
To make a template inherit from anohter, use the :extends option in template definition.
Templates are organized in sections. sections are the parts of the templates that are inherited.
Use {{super}} inside a section to render the parent section.
TEN leverages CLOS for implementing template inheritance. Templates are compiled to classes and generic functions render-template and render-section.
Have a look at some examples of template inheritance.
Includes
To include other templates, just use the output tag with the name of the included template. Remember that templates are compiled to functions; just call those functions from the template to include them.
Have a look at an example.
Dot syntax
When dot syntax is enabled (it is, by default), it is possible to conveniently access objects with dot syntax in templates:
{{ object.key1.key2 }}
that gets translated by access library to:
(access:accesses obj 'key1 'key2)
Have a look at an example.
Filters
TEN implements some convenient syntax for filters.
{{ value | func1 arg1 .. argN| func2 arg1 .. argN| .. | funcN arg1 .. argN}}
Filters are just normal functions that get applied to the value.
Filters are translated to functions application like this:
(funcN (.. (func2 (func1 value arg1 .. argN) arg1 .. argN))) arg1 .. argN)
In general, filter functions are expected to receive the value to be filtered as first parameter.
But, for several Lisp functions that's not the case. In those cases, it is possible to use _ to indicate where the filter function should receive the value.
For example, string-trim receives the string to trim as second value, so, to apply it as filter we do:
{{str | string-trim '(#\%) _}}
Filters syntax is completly optional, you can disregard it and just apply functions instead:
{{ string-trim '(#\%) (string-capitalize str) }}
Have a look at some examples of filters.
Examples
Load and have a look at the examples.
(require :ten.examples)
Example templates get compiled and exported to ten/examples package.
Troubleshooting
- When specifying a template package other than
ten-templates, if the package specified doesn't:usetenorten-templatepackages, then you may run into problems trying to compile your templates. That may be because thetemplateandsectionmacros are not found in the specified package. In that case, make sure to prefix yourtemplateandsectiondeclarations withten:, like:
{% ten:template my-template (:package my-package) %}
{% ten:section my-section %}
{% end %}
{% end %}
- Some "complex" expressions, like
condandcase, require that you turn:output-whitespacetoNIL. Otherwise, template compilation putswrite-stringexpressions right in the middle of thecaseandcondbodies. Have a look at this template.
License
MIT
Next: Files, Previous: Introduction, Up: The ten Reference Manual [Contents][Index]
2 Systems
The main system appears first, followed by any subsystem dependency.
2.1 ten
Template System for Common Lisp
- Author
Mariano Montone <marianomontone@gmail.com>
- Home Page
- License
MIT
- Long Description
# TEN
[](https://travis-ci.org/mmontone/ten)
[](http://quickdocs.org/ten/)
[](./LICENSE)
Yet another template system for Common Lisp.
TEN is a fork of [ECO template system](https://github.com/eudoxia0/eco) by Fernando Borretti.
Like ECO, TEN compiles templates to Lisp code, but has some differences:
- Two types of tags only. Control and output.
- Support for templates inheritance.
- Dot syntax for accessing template data.
- Convenient syntax for applying filters.
- Configurable syntax delimiters (planned, not done yet).
My reasons for writing yet another template system for Common Lisp is to combine the simplicity and usability of ECO (the whole Lisp language at your disposal for writing the templates), with features available in more complex template systems like [Djula](https://mmontone.github.io/djula/) that makes things easier for web development (inheritance, dot syntax, etc.).
## Usage
A TEN template looks like this:
“‘jinja
{% template ex1 () (user enabled &key items) %}
<html>
<head>
</head>
<body>
{{ user.name | string-capitalize }}
{% if enabled %}
Enabled
{% else %}
Disabled
{% end %}
{% when items %}
<ul>
{% loop for item in items do %}
<li>{{ item }}</li>
{% end %}
</ul>
{% end %}
{% when (not items) %}
There are no items
{% end %}
</body>
</html>
{% end %}
“‘
These are the types of tags:
- *Output tags*: ‘{{ <var> }}‘, becomes ‘<var>‘, and ‘{{ <fn> &rest args }}‘, that becomes ‘(fn arg1 arg2 .. argn)‘.
- *Control tags*: ‘{% <expr> %} body {% end %}‘, becomes ‘(<expr> body)‘.
- *Comments tags*: Use ‘{#‘ and ‘#}‘ to comment out a piece of template.
Control tags control which parts of the tamplate are rendered; their return value is ignored.
The value returned by output tags are interpolated into the template. The function called can be any
Lisp function, or another template (because templates are compiled to functions).
For example:
* ‘{{ user }}‘ => ‘user‘
* ‘{{ name user }}‘ => ‘(name user)‘
* ‘{% when (name user) %} ... {% end %}‘ => ‘(when (name user) ...)‘
The ‘if‘ tag is a special case: it supports using an ‘else‘ tag to separate the true and
false branches. For example:
“‘lisp
{% if posts %}
<h1>Recent Posts</h1>
... loop over posts ...
{% else %}
No recent posts.
{% end %}
“‘
Also, more [advanced control expressions](https://github.com/mmontone/ten/blob/master/examples/control.html) are possible, like ‘let‘, ‘case‘, ‘cond‘, etc.
## Template definition
Templates are defined with the following syntax:
“‘
{% template name (&rest options) (&rest args) %}
... body ...
{% end %}
“‘
Template options are:
- ‘:extends‘ : The template to extend from.
- ‘:dot-syntax‘: If T, templates are compiled with dot syntax enabled. Dot syntax is implemented via the Lisp library ‘access‘. Default is T.
- ‘:package‘: The package in which to compile and export the template. By default, templates are compiled and exported in ‘TEN-TEMPLATES‘ package.
- ‘:export‘: When T, export the generated template function. Otherwise, the template is not exported. Default is T.
- ‘:escape-html‘: Whether to escape html in output tags. Default is T.
- ‘:output-whitespace‘. Default is T. When NIL, expressions that just spit whitespace are discarded.
## Template compilation
For manually compiling templates, use ‘ten:compile-template‘ function.
But more useful is to include them in the ASDF system definition of your project.
First, add ‘:ten‘ as ASDF system definition dependency:
‘:defsystem-depends-on (:ten)‘
Then, use ‘:ten-template‘ in to include the template files:
“‘lisp
(:ten-template "filename")
“‘
The default file extension is "ten", but another can be specified via the ‘:file-extension‘ option; and the template package can be specified with the ‘:package‘ option. Look at [ten.examples ASDF system](https://github.com/mmontone/ten/blob/master/ten.examples.asd) for an example.
You can also compile all the templates in some directory using this ASDF recipe:
“‘lisp
:perform (asdf:compile-op :after (o c)
(dolist (template (uiop:directory-files (asdf:system-relative-pathname :my-app "templates/*.ten")))
(uiop:symbol-call :ten ’compile-template template)))
“‘
Templates are compiled into functions and exported in the indicated package. The default package is ‘ten-templates‘, but that can be changed from either the ASDF system definition, the ‘ten:compile-template‘ parameters, or the ‘{% template %}‘ options.
When developing your project it is useful to be able to compile templates in an interactive way.
If you are using Emacs + SLIME, load ‘ten.el‘ file.
Then use ‘M-X ten-compile-template‘ when on the template buffer to compile templates. Note that you may want to have ‘:package‘ option specified in the template so that it gets compiled into the correct package.
For debugging, you can inspect the expanded template using ‘ten:expand-template‘ function. In Emacs, go to template buffer an do ‘M-x ten-expand-template‘.
If you enable ‘ten‘ minor mode, template compilation gets conveniently bound to ‘C-c C-c‘, and template expansion to ‘C-c RET‘. Best is to automatically enable the minor mode for template files adding something like ‘(add-hook ’web-mode-hook ’ten-mode)‘ to your ‘.emacs‘ initialization file.
## Inheritance
To make a template inherit from anohter, use the ‘:extends‘ option in template definition.
Templates are organized in ‘sections‘. ‘sections‘ are the parts of the templates that are inherited.
Use ‘{{super}}‘ inside a ‘section‘ to render the parent ‘section‘.
TEN leverages CLOS for implementing template inheritance. Templates are compiled to classes and generic functions ‘render-template‘ and ‘render-section‘.
Have a look at some [examples of template inheritance](https://github.com/mmontone/ten/blob/master/examples/inheritance.html).
## Includes
To include other templates, just use the output tag with the name of the included template. Remember that templates are compiled to functions; just call those functions from the template to include them.
Have a look at [an example](https://github.com/mmontone/ten/blob/master/examples/include.html).
## Dot syntax
When dot syntax is enabled (it is, by default), it is possible to conveniently access objects with dot syntax in templates:
‘{{ object.key1.key2 }}‘
that gets translated by [access](https://github.com/AccelerationNet/access) library to:
‘(access:accesses obj ’key1 ’key2)‘
Have a look at [an example](https://github.com/mmontone/ten/blob/master/examples/dot-syntax.html).
## Filters
TEN implements some convenient syntax for filters.
‘{{ value | func1 arg1 .. argN| func2 arg1 .. argN| .. | funcN arg1 .. argN}}‘
Filters are just normal functions that get applied to the value.
Filters are translated to functions application like this:
‘(funcN (.. (func2 (func1 value arg1 .. argN) arg1 .. argN))) arg1 .. argN)‘
In general, filter functions are expected to receive the value to be filtered as first parameter.
But, for several Lisp functions that’s not the case. In those cases, it is possible to use ‘_‘ to indicate where the filter function should receive the value.
For example, ‘string-trim‘ receives the string to trim as second value, so, to apply it as filter we do:
‘{{str | string-trim ’(#\%) _}}‘
Filters syntax is completly optional, you can disregard it and just apply functions instead:
‘{{ string-trim ’(#\%) (string-capitalize str) }}‘
Have a look at some [examples of filters](https://github.com/mmontone/ten/tree/master/examples/filters.html).
## Examples
Load and have a look at the [examples](https://github.com/mmontone/ten/tree/master/examples).
“‘lisp
(require :ten.examples)
“‘
Example templates get compiled and exported to ‘ten/examples‘ package.
## Troubleshooting
1) When specifying a template package other than ‘ten-templates‘, if the package specified doesn’t ‘:use‘ ‘ten‘ or ‘ten-template‘ packages, then you may run into problems trying to compile your templates. That may be because the ‘template‘ and ‘section‘ macros are not found in the specified package. In that case, make sure to prefix your ‘template‘ and ‘section‘ declarations with ‘ten:‘, like:
“‘django
{% ten:template my-template (:package my-package) %}
{% ten:section my-section %}
{% end %}
{% end %}
“‘
2) Some "complex" expressions, like ‘cond‘ and ‘case‘, require that you turn ‘:output-whitespace‘ to ‘NIL‘. Otherwise, template compilation puts ‘write-string‘ expressions right in the middle of the ‘case‘ and ‘cond‘ bodies. Have a look at [this template](https://github.com/mmontone/ten/blob/master/examples/control.html).
## License
MIT
- Version
0.0.1
- Dependencies
- access (system).
- esrap (system).
- cl-who (system).
- split-sequence (system).
- Source
- Child Components
- package.lisp (file).
- parser.lisp (file).
- template.lisp (file).
- compiler.lisp (file).
- asdf.lisp (file).
- i18n.lisp (file).
- ten.lisp (file).
Next: Packages, Previous: Systems, Up: The ten Reference Manual [Contents][Index]
3 Files
Files are sorted by type and then listed depth-first from the systems components trees.
3.1 Lisp
- ten/ten.asd
- ten/package.lisp
- ten/parser.lisp
- ten/template.lisp
- ten/compiler.lisp
- ten/asdf.lisp
- ten/i18n.lisp
- ten/ten.lisp
Next: ten/parser.lisp, Previous: ten/ten.asd, Up: Lisp [Contents][Index]
3.1.2 ten/package.lisp
- Source
- Parent Component
ten (system).
- Packages
Next: ten/template.lisp, Previous: ten/package.lisp, Up: Lisp [Contents][Index]
3.1.3 ten/parser.lisp
- Dependency
package.lisp (file).
- Source
- Parent Component
ten (system).
- Public Interface
- <control-tag> (class).
- <else-tag> (class).
- <output-tag> (class).
- body (reader method).
- code (reader method).
- code (reader method).
- parse-template (function).
- print-object (method).
- print-object (method).
- Internals
- +end-control-delimiter+ (special variable).
- +end-output-delimiter+ (special variable).
- +start-comment-delimiter (special variable).
- +start-control-delimiter+ (special variable).
- +start-output-delimiter+ (special variable).
- +stop-comment-delimiter (special variable).
- +whitespace+ (special variable).
- <end-tag> (class).
- <fcall-tag> (class).
- <tag> (class).
- <var-tag> (class).
- def-control-without-body (function).
- parse-tokens (function).
- tokenize-template (function).
- trim-whitespace (function).
- whitespacep (function).
Next: ten/compiler.lisp, Previous: ten/parser.lisp, Up: Lisp [Contents][Index]
3.1.4 ten/template.lisp
- Dependency
parser.lisp (file).
- Source
- Parent Component
ten (system).
- Public Interface
- *create-stream-writing-functions* (special variable).
- *create-string-writing-functions* (special variable).
- *dot-syntax* (special variable).
- *escape-html* (special variable).
- *template-output* (special variable).
- begin-raw (macro).
- begin-verb (macro).
- begin-verbatim (macro).
- comment (macro).
- esc (function).
- raw (function).
- super (symbol macro).
- template (macro).
- template (class).
- verb (function).
- verbatim (function).
- Internals
- *compiling-template* (special variable).
- *export-template* (special variable).
- *output-whitespace* (special variable).
- lambda-list-slots (function).
- render-template (generic function).
- stream-writing-function-name (function).
- string-writing-function-name (function).
Next: ten/asdf.lisp, Previous: ten/template.lisp, Up: Lisp [Contents][Index]
3.1.5 ten/compiler.lisp
- Dependency
template.lisp (file).
- Source
- Parent Component
ten (system).
- Public Interface
- *template-package* (special variable).
- compile-template (function).
- Internals
- *compiling-template* (special variable).
- *output-whitespace* (special variable).
- *sections* (special variable).
- apply-filters (function).
- call-with-template-header-options (function).
- control-element-p (function).
- else-tag-p (function).
- emit (method).
- emit (method).
- emit (method).
- emit (method).
- extract-filters (function).
- finish-template-compilation (function).
- read-template-expressions (function).
- render-section (generic function).
- start-template-compilation (function).
Next: ten/i18n.lisp, Previous: ten/compiler.lisp, Up: Lisp [Contents][Index]
3.1.6 ten/asdf.lisp
- Dependency
compiler.lisp (file).
- Source
- Parent Component
ten (system).
Next: ten/ten.lisp, Previous: ten/asdf.lisp, Up: Lisp [Contents][Index]
3.1.7 ten/i18n.lisp
- Dependency
asdf.lisp (file).
- Source
- Parent Component
ten (system).
- Public Interface
_ (function).
- Internals
- *current-language* (special variable).
- *default-language* (special variable).
- *translation-backend* (special variable).
- *untranslated-messages* (special variable).
- *warn-on-untranslated-messages* (special variable).
- backend-translate (generic function).
- format-translation (function).
- translate (function).
Previous: ten/i18n.lisp, Up: Lisp [Contents][Index]
3.1.8 ten/ten.lisp
- Dependency
i18n.lisp (file).
- Source
- Parent Component
ten (system).
- Public Interface
- compile-template (function).
- expand-template (function).
Next: Definitions, Previous: Files, Up: The ten Reference Manual [Contents][Index]
4 Packages
Packages are listed by definition order.
Next: ten/compiler, Previous: ten-templates, Up: Packages [Contents][Index]
4.2 ten
- Source
- Use List
common-lisp.
- Public Interface
- compile-template (function).
- expand-template (function).
Next: ten/parser, Previous: ten, Up: Packages [Contents][Index]
4.3 ten/compiler
- Source
- Use List
- common-lisp.
- ten/parser.
- ten/template.
- Public Interface
- *template-package* (special variable).
- compile-template (function).
- Internals
- *compiling-template* (special variable).
- *output-whitespace* (special variable).
- *sections* (special variable).
- apply-filters (function).
- call-with-template-header-options (function).
- control-element-p (function).
- else-tag-p (function).
- emit (generic function).
- extract-filters (function).
- finish-template-compilation (function).
- read-template-expressions (function).
- render-section (generic function).
- start-template-compilation (function).
Next: ten/template, Previous: ten/compiler, Up: Packages [Contents][Index]
4.4 ten/parser
- Source
- Use List
- common-lisp.
- esrap.
- Used By List
- Public Interface
- <control-tag> (class).
- <else-tag> (class).
- <output-tag> (class).
- body (generic reader).
- code (generic reader).
- parse-template (function).
- Internals
- +end-control-delimiter+ (special variable).
- +end-output-delimiter+ (special variable).
- +start-comment-delimiter (special variable).
- +start-control-delimiter+ (special variable).
- +start-output-delimiter+ (special variable).
- +stop-comment-delimiter (special variable).
- +whitespace+ (special variable).
- <end-tag> (class).
- <fcall-tag> (class).
- <tag> (class).
- <var-tag> (class).
- def-control-without-body (function).
- parse-tokens (function).
- tokenize-template (function).
- trim-whitespace (function).
- whitespacep (function).
Previous: ten/parser, Up: Packages [Contents][Index]
4.5 ten/template
- Source
- Use List
common-lisp.
- Used By List
- Public Interface
- *create-stream-writing-functions* (special variable).
- *create-string-writing-functions* (special variable).
- *dot-syntax* (special variable).
- *escape-html* (special variable).
- *template-output* (special variable).
- _ (function).
- begin-raw (macro).
- begin-verb (macro).
- begin-verbatim (macro).
- comment (macro).
- esc (function).
- raw (function).
- super (symbol macro).
- template (macro).
- template (class).
- verb (function).
- verbatim (function).
- Internals
- *compiling-template* (special variable).
- *current-language* (special variable).
- *default-language* (special variable).
- *export-template* (special variable).
- *output-whitespace* (special variable).
- *translation-backend* (special variable).
- *untranslated-messages* (special variable).
- *warn-on-untranslated-messages* (special variable).
- backend-translate (generic function).
- format-translation (function).
- lambda-list-slots (function).
- render-template (generic function).
- stream-writing-function-name (function).
- string-writing-function-name (function).
- translate (function).
Next: Indexes, Previous: Packages, Up: The ten Reference Manual [Contents][Index]
5 Definitions
Definitions are sorted by export status, category, package, and then by lexicographic order.
Next: Internals, Previous: Definitions, Up: Definitions [Contents][Index]
5.1 Public Interface
- Special variables
- Symbol macros
- Macros
- Ordinary functions
- Generic functions
- Standalone methods
- Classes
Next: Symbol macros, Previous: Public Interface, Up: Public Interface [Contents][Index]
5.1.1 Special variables
- Special Variable: *create-stream-writing-functions* ¶
-
- Package
- Source
- Special Variable: *create-string-writing-functions* ¶
-
- Package
- Source
- Special Variable: *dot-syntax* ¶
-
- Package
- Source
- Special Variable: *escape-html* ¶
-
- Package
- Source
- Special Variable: *template-output* ¶
-
- Package
- Source
- Special Variable: *template-package* ¶
-
The package where template expressions are evaluated and the template function is exported
- Package
- Source
Next: Macros, Previous: Special variables, Up: Public Interface [Contents][Index]
5.1.2 Symbol macros
- Symbol Macro: super ¶
-
- Package
- Source
Next: Ordinary functions, Previous: Symbol macros, Up: Public Interface [Contents][Index]
5.1.3 Macros
- Macro: begin-raw (&body body) ¶
-
- Package
- Source
- Macro: begin-verb (&body body) ¶
-
- Package
- Source
- Macro: begin-verbatim (&body body) ¶
-
- Package
- Source
- Macro: comment (&body body) ¶
-
- Package
- Source
- Macro: template (name (&key extends package escape-html export dot-syntax output-whitespace create-string-writing-function create-stream-writing-function) args &rest body) ¶
-
The main template creation macro.
Arguments:
- EXTENDS: the name of the template to extend from.
- PACKAGE: the package within which the compiled template is to be defined.
- EXPORT: when T, the generated template function is exported.
- ESCAPE-HTML: whether to escape HTML or not. Default is controlled by *ESCAPE-HTML*, which is true by default.
- OUTPUT-WHITESPACE: whether to output whitespaces or not. Default is controlled by *OUTPUT-WHITESPACE*, which is true by default.
- CREATE-STRING-WRITING-FUNCTION: controls whether a function that writes the template to a string should be created. Default is T.
- CREATE-STREAM-WRITING-FUNCTION: controls whether a function that writes the template to *TEMPLATE-OUTPUT* stream should be created. Default is false.IMPORTANT: some of this macro arguments are processed by CALL-WITH-TEMPLATE-HEADER-OPTIONS, not here. That’s why we declare some of them as ignored.
- Package
- Source
Next: Generic functions, Previous: Macros, Up: Public Interface [Contents][Index]
5.1.4 Ordinary functions
- Function: _ (string &rest args) ¶
-
- Package
- Source
- Function: compile-template (string-or-pathname &optional package-name) ¶
-
Compile a template. If a pathname is given, compiles the file content. Otherwise, compiles the given string.
- Function: compile-template (elements &optional package-name) ¶
-
- Package
- Source
- Function: esc (string) ¶
-
Escape a string.
- Package
- Source
- Function: expand-template (string-or-pathname &optional package-name) ¶
-
Expand a template to Lisp code. Useful for debugging.
- Function: parse-template (string-or-pathname) ¶
-
- Package
- Source
- Function: raw (str) ¶
-
- Package
- Source
- Function: verb (str) ¶
-
- Package
- Source
- Function: verbatim (str) ¶
-
- Package
- Source
Next: Standalone methods, Previous: Ordinary functions, Up: Public Interface [Contents][Index]
5.1.5 Generic functions
- Generic Reader: body (object) ¶
-
- Package
- Methods
- Reader Method: body ((<control-tag> <control-tag>)) ¶
-
automatically generated reader method
- Source
- Target Slot
body.
- Generic Reader: code (object) ¶
-
- Package
- Methods
- Reader Method: code ((<control-tag> <control-tag>)) ¶
-
automatically generated reader method
- Source
- Target Slot
code.
- Reader Method: code ((<output-tag> <output-tag>)) ¶
-
automatically generated reader method
- Source
- Target Slot
code.
Next: Classes, Previous: Generic functions, Up: Public Interface [Contents][Index]
5.1.6 Standalone methods
- Method: print-object ((tag <output-tag>) stream) ¶
-
- Source
- Method: print-object ((tag <control-tag>) stream) ¶
-
- Source
Previous: Standalone methods, Up: Public Interface [Contents][Index]
5.1.7 Classes
- Class: <control-tag> ¶
-
- Package
- Source
- Direct superclasses
- Direct methods
- body.
- code.
- emit.
- print-object.
- Direct slots
- Class: <else-tag> ¶
-
- Package
- Source
- Direct superclasses
- Class: <output-tag> ¶
-
- Package
- Source
- Direct superclasses
- Direct subclasses
- Direct methods
- code.
- emit.
- print-object.
- Direct slots
- Class: template ¶
-
- Package
- Source
Previous: Public Interface, Up: Definitions [Contents][Index]
5.2 Internals
Next: Ordinary functions, Previous: Internals, Up: Internals [Contents][Index]
5.2.1 Special variables
- Special Variable: *compiling-template* ¶
-
- Package
- Source
- Special Variable: *compiling-template* ¶
-
- Package
- Source
- Special Variable: *current-language* ¶
-
- Package
- Source
- Special Variable: *default-language* ¶
-
- Package
- Source
- Special Variable: *export-template* ¶
-
Export the templates by default
- Package
- Source
- Special Variable: *output-whitespace* ¶
-
- Package
- Source
- Special Variable: *output-whitespace* ¶
-
- Package
- Source
- Special Variable: *sections* ¶
-
- Package
- Source
- Special Variable: *translation-backend* ¶
-
The translation backend.
- Package
- Source
- Special Variable: *untranslated-messages* ¶
-
- Package
- Source
- Special Variable: *warn-on-untranslated-messages* ¶
-
- Package
- Source
- Special Variable: +end-control-delimiter+ ¶
-
- Package
- Source
- Special Variable: +end-output-delimiter+ ¶
-
- Package
- Source
- Special Variable: +start-comment-delimiter ¶
-
- Package
- Source
- Special Variable: +start-control-delimiter+ ¶
-
- Package
- Source
- Special Variable: +start-output-delimiter+ ¶
-
- Package
- Source
- Special Variable: +stop-comment-delimiter ¶
-
- Package
- Source
- Special Variable: +whitespace+ ¶
-
- Package
- Source
Next: Generic functions, Previous: Special variables, Up: Internals [Contents][Index]
5.2.2 Ordinary functions
- Function: apply-filters (code filters) ¶
-
- Package
- Source
- Function: call-with-template-header-options (header func) ¶
-
- Package
- Source
- Function: control-element-p (element) ¶
-
- Package
- Source
- Function: def-control-without-body (symbol) ¶
-
- Package
- Source
- Function: else-tag-p (element) ¶
-
- Package
- Source
- Function: extract-filters (string) ¶
-
- Package
- Source
- Function: finish-template-compilation (template-name result) ¶
-
- Package
- Source
- Function: format-translation (string &rest args) ¶
-
- Package
- Source
- Function: lambda-list-slots (args) ¶
-
- Package
- Source
- Function: parse-tokens (tokens) ¶
-
- Package
- Source
- Function: read-template-expressions (string) ¶
-
- Package
- Source
- Function: start-template-compilation (template-name) ¶
-
- Package
- Source
- Function: stream-writing-function-name (name) ¶
-
- Package
- Source
- Function: string-writing-function-name (name) ¶
-
- Package
- Source
- Function: tokenize-template (string) ¶
-
- Package
- Source
- Function: translate (string &optional args language backend) ¶
-
- Package
- Source
- Function: trim-whitespace (str) ¶
-
- Package
- Source
- Function: whitespacep (char) ¶
-
- Package
- Source
Next: Classes, Previous: Ordinary functions, Up: Internals [Contents][Index]
5.2.3 Generic functions
- Generic Function: backend-translate (backend string language &rest args) ¶
- Generic Function: emit (str) ¶
-
- Package
- Methods
- Method: emit ((tag <control-tag>)) ¶
-
- Source
- Method: emit ((tag <output-tag>)) ¶
-
- Source
- Method: emit ((vec vector)) ¶
-
- Source
- Method: emit ((str string)) ¶
-
- Source
- Generic Function: render-section (section-name template stream) ¶
-
- Package
- Source
- Generic Function: render-template (template stream) ¶
-
- Package
- Source
Previous: Definitions, Up: The ten Reference Manual [Contents][Index]
Appendix A Indexes
A.2 Functions
| Jump to: | _
A B C D E F G L M P R S T V W |
|---|
| Jump to: | _
A B C D E F G L M P R S T V W |
|---|
Next: Data types, Previous: Functions, Up: Indexes [Contents][Index]
A.3 Variables
| Jump to: | *
+
B C S |
|---|
| Jump to: | *
+
B C S |
|---|
A.4 Data types
| Jump to: | <
A C F I P S T |
|---|
| Jump to: | <
A C F I P S T |
|---|