Short Overview of Templet 3.0
A Scripting Language for the Web
18 January 1999

The Templet language was developed initially as a server-side scripting language for generating HTML. However, it is suitable for client-side scripting as well, although availability of the client-side plug-in will follow availability of the rest of the system.

As a standalone system, Templet is suitable for many other text generation and string processing tasks, including XML processing. It is, in fact, a complete general-purpose programming language.

Relation to HTML

Templet was designed to integrate well with HTML and derives its main syntactic features from HTML. The principal driving force for Templet 1.0 was to make it as easy as possible for HTML developers to initially use a small set of Templet features that mimicked HTML features. As Templet has evolved, it has grown somewhat more complex, but the essential principle of HTML similarity remains. In particular

HTML uses angle brackets to enclose HTML tags; Templet uses square brackets. In the simplest case, these perform simple substitutions intermingled with the HTML, for example
```
  Today is [today], [shortdate].
```
which uses the built-in Template functions today and shortdate and substitutes their results in the text, generating, for example
```
  Today is Monday, 10/26/98.
```
HTML uses parameters separated by blanks, as does Templet, although Templet uses unnamed parameters. For example:
```
  [sum 3 4]   => 7
```
HTML uses paired tags, of the form name and /name. So does Templet, for example
```
 I [if ([user] == Hillary)] <b>really</b> [/if] love you.
```
will display
unless the user is Hillary, in which case it displays

Power and Simplicity

Templet 3.0 is a programming language that has great power, yet can support frequently used idioms with great simplicity. For example, by combining its loop, string list, and substitution features, one can write

  [foreach Sandi|Andee|Kathleen]
    I loved [$].<br>
  [/foreach]

which will display

A local variable could have been used to store the list of names, so the display above could also have been generated by

  [do &names = Sandi|Andee|Kathleen]
  [foreach &names]
    I loved [$].<br>
  [/foreach]

Adding optional clauses provides even more power:

  [foreach Sandi|Andee|Kathleen][:trim][:separate ", and "]
    I loved [$]
  [/foreach]!

generates

I loved Sandi, and I loved Andee, and I loved Kathleen! Dynamic generation of input controls is just as easy. For example

  I loved
  <SELECT>
    [foreach Sandi|Andee|Kathleen]
      <OPTION VALUE="[$]">[$]
    [/foreach]
  </SELECT>

generates

Database extraction is almost as easy. The DB.SELECT function uses standard SQL, except the SQL itself can be dynamically generated in the same way that other text is. To display all marriages recorded in the Marriages table in the past year, write:

  [do
    &cutoff = [date];
    &cutoff.year--;
  ]
  [DB.SELECT husband, wife, marrydate
    FROM Marriages
    WHERE marrydate > [&cutoff]
  ]
      [$husband] was married to [$wife] on [$marrydate].<br>
  [/SELECT]

which could generate

Including the appropriate HTML will generate a table instead:

  <TABLE BORDER=1 CELLSPACING=1>
    <TR>
    [foreach Husband|Wife|Date]
      <TD><B>[$]</B></TD>
    [/foreach]
    </TR>
  [do
    &cutoff = [date];
    &cutoff.year--;
  ]
  [DB.SELECT husband, wife, marrydate
    FROM Marriages
    WHERE marrydate > [&cutoff]
  ]
    <TR>
    [foreach [$husband]|[$wife]|[$marrydate]]
      <TD>[$]</TD>
    [/foreach]
    </TR>
  [/SELECT]
  </TABLE>

could generate

Husband	Wife	Date
Joe Johnson	Tillie Tillson	June 14, 1998
Sam Samuels	Joan Jolson	August 19, 1998
Pete Peters	Sandi Sanders	September 4, 1998

Features

Templet's syntactic and semantic model borrows features from a somewhat eclectic set of programming languages including (in alphabetical order) Alphard, APL, Java, Javascript, Perl, Scheme (and other LISPs), and Smalltalk.

The Templet 3.0 design is distinguished by the following features:

The representation of all primitive and composite values as objects, each object potentially containing both named and indexed fields
A built-in String object, also used to represent numbers, both integers and reals, as well as lists of strings.
Support for freezing individual fields as well as entire objects
A class model with support for delegation, derivation, and multiple hierarchical class extension.
The explicit representation of both the execution environment and various naming contexts in that environment as objects, with variables representing fields in naming context objects.
The use of prefixes to distinguish among variables in different naming contexts, and the corresponding absence of naming scopes and name hiding.
Consistent support for dynamically constructed variables, names, and indices.
Functions that carry with them a reference to the environment in which they were defined, and that can specify how the environment created by their invocation can include contexts from both the defining and the calling environment.
The use of aliases -- non-object entities -- to identify a specific field in a specific object, and to provide a transparent indirection mechanism.
The generalization of function application to arbitrary object application, using a Lisp-like syntax with blanks as parameter separators.
The use of application and implicit concatenation as the only essential operators in Templet, with optional field access operators for convenience.
A large number of parameter mechanisms, that vary based on whether the actual parameter is
- quoted, evaluated, or encapsulated as a function
- treated as a value or as a variable name
- resolved to an alias, an object, or either
Support for functions with
- optional and (potentially arbitrarily) repeated parameters
- syntactically separated groups of such parameters, which also may be optional and repeated, with casting used to ensure unambiguous parsing.
- parameters embedded between parameter groups, similar to text embedded between HTML paired tags
The absence of declarative syntax, and the corresponding use of application (ala Lisp) to represent typical declarations (but executed at run-time) and statements, including class and function definitions and control statements.
A unified mechanism replacing the Java equivalents of return, break, continue, and throw.
Support for evaluating strings as code, and for quasi-quoting and quasi-evaluation
Functions whose code is invoked at compile-time, replacing the function invocation by a string representing alternative code which is compiled in its place.
Full support for infix-mode, using compile-time replacement functions.
User-defined aliases and mediators, non-object entities, which can mediate access to fields and objects, supporting access control, debugging, and constraint maintenance.

Templet comes with a wide variety of built-in and library classes, including Class, Object, String, List, Dictionary, SortedList, SortedDictionary, Date, Time, Timestamp, Function, Environment, Conductor, Promise, LazyList, Enumeration, Stream, PatternMatcher, Thread, Lock, Database and Query.

Templet also includes classes that provide significant server-side functionality and web support, including transparent construction of URLs for links, (frame & image) sources, and forms. Exercising these URLs invokes specified server-side Templet functions, passing along request-specific values and/or automatically generated session-id's, which are either encoded in the URL or provided via cookies. These classes also provide functions that simplify construction of input elements, especially those with dynamically-determined initial values.

As a web-driven back-end, Templet can either run as a Java servlet or as a separate Templet server, depending on a servlet, other server plug-in or CGI program to pass appropriate HTTP requests on to the Templet server; other configurations can be readily supported.

Templet's built-in functions are implemented in Java; user-defined functions can be implemented in Java as well. Public Java API's for all Templet object are available for use within user-defined functions.

There is no present support for a security model. Currently we assume that all code is server-side and open. Any access controls (e.g. private fields) are to support programming safety rather than security.

For more information on Templet's features, see

You can also find out about the history of Templet.

Contact Ellis S. Cohen (e.cohen@acm.org) for more information on availability or on how you can participate in the implementation.

Disclaimer

Short Overview of Templet 3.0 A Scripting Language for the Web 18 January 1999

Relation to HTML

Power and Simplicity

Features

Short Overview of Templet 3.0
A Scripting Language for the Web
18 January 1999