The ten Reference Manual

Table of Contents

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

The ten Reference Manual

This is the ten Reference Manual, version 0.0.1, generated automatically by Declt version 3.0 "Montgomery Scott" on Tue Apr 28 13:06:10 2020 GMT+0.


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

1 Introduction

TEN

Build Status Quicklisp MIT License

Yet another template system for Common Lisp.

WIP

NOTE: This is alpha quality. Not all design decisions have been made yet and things are subject to change.

TEN is a fork of ECO template system by Fernando Borretti.

Like ECO, TEN compiles templates to Lisp code, but has some differences:

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 %}

There are two types of tags:

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:

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:

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 :filename-extension option; and the template package can be specified with the :package option. Look at ten.examples ASDF system for an example.

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)

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:
{% ten:template my-template (:package my-package) %}
{% ten:section my-section %}
{% end %}
{% end %}
  1. 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.

License

MIT


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 ten

Author

Mariano Montone <marianomontone@gmail.com>

License

MIT

Description

Template System for Common Lisp

Long Description

# TEN

[![Build Status](https://travis-ci.org/mmontone/ten.svg?branch=master)](https://travis-ci.org/mmontone/ten)
[![Quicklisp](http://quickdocs.org/badge/ten.svg)](http://quickdocs.org/ten/)
[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)

Yet another template system for Common Lisp.

WIP

NOTE: This is alpha quality. Not all design decisions have been made yet and things are subject to change.

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 %}

“‘

There are two 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)‘.

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.
- ‘: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 ‘:filename-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.

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)
“‘

## 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
Source

ten.asd (file)

Components

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

3 Files

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


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

3.1 Lisp


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

3.1.1 ten.asd

Location

ten.asd

Systems

ten (system)


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

3.1.2 ten/package.lisp

Parent

ten (system)

Location

package.lisp

Packages

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

3.1.3 ten/parser.lisp

Dependency

package.lisp (file)

Parent

ten (system)

Location

parser.lisp

Exported Definitions
Internal Definitions

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

3.1.4 ten/template.lisp

Dependency

parser.lisp (file)

Parent

ten (system)

Location

template.lisp

Exported Definitions
Internal Definitions

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

3.1.5 ten/compiler.lisp

Dependency

template.lisp (file)

Parent

ten (system)

Location

compiler.lisp

Exported Definitions
Internal Definitions

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

3.1.6 ten/asdf.lisp

Dependency

compiler.lisp (file)

Parent

ten (system)

Location

asdf.lisp


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

3.1.7 ten/i18n.lisp

Dependency

asdf.lisp (file)

Parent

ten (system)

Location

i18n.lisp

Exported Definitions

_ (function)

Internal Definitions

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

3.1.8 ten/ten.lisp

Dependency

i18n.lisp (file)

Parent

ten (system)

Location

ten.lisp

Exported Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 ten/template

Source

package.lisp (file)

Use List

common-lisp

Used By List
Exported Definitions
Internal Definitions

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

4.2 ten/parser

Source

package.lisp (file)

Use List
Used By List

ten/compiler

Exported Definitions
Internal Definitions

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

4.3 ten/compiler

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

4.4 ten

Source

package.lisp (file)

Use List

common-lisp

Exported Definitions

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

4.5 ten-templates

Source

package.lisp (file)

Use List

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Special variables

Special Variable: *template-package*

The package where template expressions are evaluated and the template function is exported

Package

ten/compiler

Source

compiler.lisp (file)


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

5.1.2 Symbol macros

Symbol Macro: super
Package

ten/template

Source

template.lisp (file)

Expansion

(progn (call-next-method) "")


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

5.1.3 Macros

Macro: begin-raw &body BODY
Package

ten/template

Source

template.lisp (file)

Macro: begin-verb &body BODY
Package

ten/template

Source

template.lisp (file)

Macro: begin-verbatim &body BODY
Package

ten/template

Source

template.lisp (file)

Macro: template NAME (&key EXTENDS PACKAGE ESCAPE-HTML DOT-SYNTAX OUTPUT-WHITESPACE) ARGS &rest BODY
Package

ten/template

Source

template.lisp (file)


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

5.1.4 Functions

Function: _ STRING &rest ARGS
Package

ten/template

Source

i18n.lisp (file)

Function: compile-template ELEMENTS &optional PACKAGE-NAME
Package

ten/compiler

Source

compiler.lisp (file)

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.

Package

ten

Source

ten.lisp (file)

Function: esc STRING

Escape a string.

Package

ten/template

Source

template.lisp (file)

Function: expand-template STRING-OR-PATHNAME &optional PACKAGE-NAME

Expand a template to Lisp code. Useful for debugging.

Package

ten

Source

ten.lisp (file)

Function: parse-template STRING-OR-PATHNAME
Package

ten/parser

Source

parser.lisp (file)

Function: raw STR
Package

ten/template

Source

template.lisp (file)

Function: verb STR
Package

ten/template

Source

template.lisp (file)

Function: verbatim STR
Package

ten/template

Source

template.lisp (file)


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

5.1.5 Generic functions

Generic Function: body OBJECT
Package

ten/parser

Methods
Method: body (<CONTROL-TAG> <control-tag>)

automatically generated reader method

Source

parser.lisp (file)

Generic Function: code OBJECT
Package

ten/parser

Methods
Method: code (<CONTROL-TAG> <control-tag>)

automatically generated reader method

Source

parser.lisp (file)

Method: code (<OUTPUT-TAG> <output-tag>)

automatically generated reader method

Source

parser.lisp (file)


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

5.1.6 Classes

Class: <control-tag> ()
Package

ten/parser

Source

parser.lisp (file)

Direct superclasses

<tag> (class)

Direct methods
  • emit (method)
  • print-object (method)
  • body (method)
  • code (method)
Direct slots
Slot: code
Initargs

:code

Readers

code (generic function)

Slot: body
Initargs

:body

Readers

body (generic function)

Class: <else-tag> ()
Package

ten/parser

Source

parser.lisp (file)

Direct superclasses

<tag> (class)

Class: <output-tag> ()
Package

ten/parser

Source

parser.lisp (file)

Direct superclasses

<tag> (class)

Direct subclasses
Direct methods
  • emit (method)
  • print-object (method)
  • code (method)
Direct slots
Slot: code
Initargs

:code

Readers

code (generic function)

Class: template ()
Package

ten/template

Source

template.lisp (file)

Direct superclasses

standard-object (class)


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

5.2 Internal definitions


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

5.2.1 Special variables

Special Variable: *compiling-template*
Package

ten/template

Source

template.lisp (file)

Special Variable: *compiling-template*
Package

ten/compiler

Source

compiler.lisp (file)

Special Variable: *current-language*
Package

ten/template

Source

i18n.lisp (file)

Special Variable: *default-language*
Package

ten/template

Source

i18n.lisp (file)

Special Variable: *dot-syntax*
Package

ten/template

Source

template.lisp (file)

Special Variable: *escape-html*
Package

ten/template

Source

template.lisp (file)

Special Variable: *output-whitespace*
Package

ten/template

Source

template.lisp (file)

Special Variable: *output-whitespace*
Package

ten/compiler

Source

compiler.lisp (file)

Special Variable: *sections*
Package

ten/compiler

Source

compiler.lisp (file)

Special Variable: *template-output*
Package

ten/template

Source

template.lisp (file)

Special Variable: *translation-backend*

The translation backend.

Package

ten/template

Source

i18n.lisp (file)

Special Variable: *untranslated-messages*
Package

ten/template

Source

i18n.lisp (file)

Special Variable: *warn-on-untranslated-messages*
Package

ten/template

Source

i18n.lisp (file)

Special Variable: +end-control-delimiter+
Package

ten/parser

Source

parser.lisp (file)

Special Variable: +end-output-delimiter+
Package

ten/parser

Source

parser.lisp (file)

Special Variable: +start-control-delimiter+
Package

ten/parser

Source

parser.lisp (file)

Special Variable: +start-output-delimiter+
Package

ten/parser

Source

parser.lisp (file)

Special Variable: +whitespace+
Package

ten/parser

Source

parser.lisp (file)


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

5.2.2 Functions

Function: apply-filters CODE FILTERS
Package

ten/compiler

Source

compiler.lisp (file)

Function: call-with-template-header-options HEADER FUNC
Package

ten/compiler

Source

compiler.lisp (file)

Function: control-element-p ELEMENT
Package

ten/compiler

Source

compiler.lisp (file)

Function: def-control-without-body SYMBOL
Package

ten/parser

Source

parser.lisp (file)

Function: else-tag-p ELEMENT
Package

ten/compiler

Source

compiler.lisp (file)

Function: extract-filters STRING
Package

ten/compiler

Source

compiler.lisp (file)

Function: finish-template-compilation TEMPLATE-NAME RESULT
Package

ten/compiler

Source

compiler.lisp (file)

Function: format-translation STRING &rest ARGS
Package

ten/template

Source

i18n.lisp (file)

Function: lambda-list-slots ARGS
Package

ten/template

Source

template.lisp (file)

Function: parse-tokens TOKENS
Package

ten/parser

Source

parser.lisp (file)

Function: read-template-expressions STRING
Package

ten/compiler

Source

compiler.lisp (file)

Function: start-template-compilation TEMPLATE-NAME
Package

ten/compiler

Source

compiler.lisp (file)

Function: tokenize-template STRING
Package

ten/parser

Source

parser.lisp (file)

Function: translate STRING &optional ARGS LANGUAGE BACKEND
Package

ten/template

Source

i18n.lisp (file)

Function: trim-whitespace STR
Package

ten/parser

Source

parser.lisp (file)

Function: whitespacep CHAR
Package

ten/parser

Source

parser.lisp (file)


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

5.2.3 Generic functions

Generic Function: backend-translate BACKEND STRING LANGUAGE &rest ARGS
Package

ten/template

Source

i18n.lisp (file)

Methods
Method: backend-translate (BACKEND null) STRING LANGUAGE &rest ARGS
Method: backend-translate BACKEND STRING LANGUAGE &rest ARGS
Generic Function: emit STR
Package

ten/compiler

Methods
Method: emit (TAG <control-tag>)
Source

compiler.lisp (file)

Method: emit (TAG <output-tag>)
Source

compiler.lisp (file)

Method: emit (VEC vector)
Source

compiler.lisp (file)

Method: emit (STR string)
Source

compiler.lisp (file)

Generic Function: render-section SECTION-NAME TEMPLATE STREAM
Package

ten/compiler

Source

compiler.lisp (file)

Generic Function: render-template TEMPLATE STREAM
Package

ten/template

Source

template.lisp (file)


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

5.2.4 Classes

Class: <end-tag> ()
Package

ten/parser

Source

parser.lisp (file)

Direct superclasses

<tag> (class)

Class: <fcall-tag> ()
Package

ten/parser

Source

parser.lisp (file)

Direct superclasses

<output-tag> (class)

Class: <tag> ()
Package

ten/parser

Source

parser.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Class: <var-tag> ()
Package

ten/parser

Source

parser.lisp (file)

Direct superclasses

<output-tag> (class)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L   T  
Index Entry  Section

F
File, Lisp, ten.asd: The ten․asd file
File, Lisp, ten/asdf.lisp: The ten/asdf․lisp file
File, Lisp, ten/compiler.lisp: The ten/compiler․lisp file
File, Lisp, ten/i18n.lisp: The ten/i18n․lisp file
File, Lisp, ten/package.lisp: The ten/package․lisp file
File, Lisp, ten/parser.lisp: The ten/parser․lisp file
File, Lisp, ten/template.lisp: The ten/template․lisp file
File, Lisp, ten/ten.lisp: The ten/ten․lisp file

L
Lisp File, ten.asd: The ten․asd file
Lisp File, ten/asdf.lisp: The ten/asdf․lisp file
Lisp File, ten/compiler.lisp: The ten/compiler․lisp file
Lisp File, ten/i18n.lisp: The ten/i18n․lisp file
Lisp File, ten/package.lisp: The ten/package․lisp file
Lisp File, ten/parser.lisp: The ten/parser․lisp file
Lisp File, ten/template.lisp: The ten/template․lisp file
Lisp File, ten/ten.lisp: The ten/ten․lisp file

T
ten.asd: The ten․asd file
ten/asdf.lisp: The ten/asdf․lisp file
ten/compiler.lisp: The ten/compiler․lisp file
ten/i18n.lisp: The ten/i18n․lisp file
ten/package.lisp: The ten/package․lisp file
ten/parser.lisp: The ten/parser․lisp file
ten/template.lisp: The ten/template․lisp file
ten/ten.lisp: The ten/ten․lisp file

Jump to:   F   L   T  

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

A.2 Functions

Jump to:   _  
A   B   C   D   E   F   G   L   M   P   R   S   T   V   W  
Index Entry  Section

_
_: Exported functions

A
apply-filters: Internal functions

B
backend-translate: Internal generic functions
backend-translate: Internal generic functions
backend-translate: Internal generic functions
begin-raw: Exported macros
begin-verb: Exported macros
begin-verbatim: Exported macros
body: Exported generic functions
body: Exported generic functions

C
call-with-template-header-options: Internal functions
code: Exported generic functions
code: Exported generic functions
code: Exported generic functions
compile-template: Exported functions
compile-template: Exported functions
control-element-p: Internal functions

D
def-control-without-body: Internal functions

E
else-tag-p: Internal functions
emit: Internal generic functions
emit: Internal generic functions
emit: Internal generic functions
emit: Internal generic functions
emit: Internal generic functions
esc: Exported functions
expand-template: Exported functions
extract-filters: Internal functions

F
finish-template-compilation: Internal functions
format-translation: Internal functions
Function, apply-filters: Internal functions
Function, call-with-template-header-options: Internal functions
Function, compile-template: Exported functions
Function, compile-template: Exported functions
Function, control-element-p: Internal functions
Function, def-control-without-body: Internal functions
Function, else-tag-p: Internal functions
Function, esc: Exported functions
Function, expand-template: Exported functions
Function, extract-filters: Internal functions
Function, finish-template-compilation: Internal functions
Function, format-translation: Internal functions
Function, lambda-list-slots: Internal functions
Function, parse-template: Exported functions
Function, parse-tokens: Internal functions
Function, raw: Exported functions
Function, read-template-expressions: Internal functions
Function, start-template-compilation: Internal functions
Function, tokenize-template: Internal functions
Function, translate: Internal functions
Function, trim-whitespace: Internal functions
Function, verb: Exported functions
Function, verbatim: Exported functions
Function, whitespacep: Internal functions
Function, _: Exported functions

G
Generic Function, backend-translate: Internal generic functions
Generic Function, body: Exported generic functions
Generic Function, code: Exported generic functions
Generic Function, emit: Internal generic functions
Generic Function, render-section: Internal generic functions
Generic Function, render-template: Internal generic functions

L
lambda-list-slots: Internal functions

M
Macro, begin-raw: Exported macros
Macro, begin-verb: Exported macros
Macro, begin-verbatim: Exported macros
Macro, template: Exported macros
Method, backend-translate: Internal generic functions
Method, backend-translate: Internal generic functions
Method, body: Exported generic functions
Method, code: Exported generic functions
Method, code: Exported generic functions
Method, emit: Internal generic functions
Method, emit: Internal generic functions
Method, emit: Internal generic functions
Method, emit: Internal generic functions

P
parse-template: Exported functions
parse-tokens: Internal functions

R
raw: Exported functions
read-template-expressions: Internal functions
render-section: Internal generic functions
render-template: Internal generic functions

S
start-template-compilation: Internal functions

T
template: Exported macros
tokenize-template: Internal functions
translate: Internal functions
trim-whitespace: Internal functions

V
verb: Exported functions
verbatim: Exported functions

W
whitespacep: Internal functions

Jump to:   _  
A   B   C   D   E   F   G   L   M   P   R   S   T   V   W  

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

A.3 Variables

Jump to:   *   +  
B   C   S  
Index Entry  Section

*
*compiling-template*: Internal special variables
*compiling-template*: Internal special variables
*current-language*: Internal special variables
*default-language*: Internal special variables
*dot-syntax*: Internal special variables
*escape-html*: Internal special variables
*output-whitespace*: Internal special variables
*output-whitespace*: Internal special variables
*sections*: Internal special variables
*template-output*: Internal special variables
*template-package*: Exported special variables
*translation-backend*: Internal special variables
*untranslated-messages*: Internal special variables
*warn-on-untranslated-messages*: Internal special variables

+
+end-control-delimiter+: Internal special variables
+end-output-delimiter+: Internal special variables
+start-control-delimiter+: Internal special variables
+start-output-delimiter+: Internal special variables
+whitespace+: Internal special variables

B
body: Exported classes

C
code: Exported classes
code: Exported classes

S
Slot, body: Exported classes
Slot, code: Exported classes
Slot, code: Exported classes
Special Variable, *compiling-template*: Internal special variables
Special Variable, *compiling-template*: Internal special variables
Special Variable, *current-language*: Internal special variables
Special Variable, *default-language*: Internal special variables
Special Variable, *dot-syntax*: Internal special variables
Special Variable, *escape-html*: Internal special variables
Special Variable, *output-whitespace*: Internal special variables
Special Variable, *output-whitespace*: Internal special variables
Special Variable, *sections*: Internal special variables
Special Variable, *template-output*: Internal special variables
Special Variable, *template-package*: Exported special variables
Special Variable, *translation-backend*: Internal special variables
Special Variable, *untranslated-messages*: Internal special variables
Special Variable, *warn-on-untranslated-messages*: Internal special variables
Special Variable, +end-control-delimiter+: Internal special variables
Special Variable, +end-output-delimiter+: Internal special variables
Special Variable, +start-control-delimiter+: Internal special variables
Special Variable, +start-output-delimiter+: Internal special variables
Special Variable, +whitespace+: Internal special variables
super: Exported symbol macros
Symbol Macro, super: Exported symbol macros

Jump to:   *   +  
B   C   S  

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

A.4 Data types

Jump to:   <  
C   P   S   T  
Index Entry  Section

<
<control-tag>: Exported classes
<else-tag>: Exported classes
<end-tag>: Internal classes
<fcall-tag>: Internal classes
<output-tag>: Exported classes
<tag>: Internal classes
<var-tag>: Internal classes

C
Class, <control-tag>: Exported classes
Class, <else-tag>: Exported classes
Class, <end-tag>: Internal classes
Class, <fcall-tag>: Internal classes
Class, <output-tag>: Exported classes
Class, <tag>: Internal classes
Class, <var-tag>: Internal classes
Class, template: Exported classes

P
Package, ten: The ten package
Package, ten-templates: The ten-templates package
Package, ten/compiler: The ten/compiler package
Package, ten/parser: The ten/parser package
Package, ten/template: The ten/template package

S
System, ten: The ten system

T
template: Exported classes
ten: The ten system
ten: The ten package
ten-templates: The ten-templates package
ten/compiler: The ten/compiler package
ten/parser: The ten/parser package
ten/template: The ten/template package

Jump to:   <  
C   P   S   T