I'm intrigued. You might have noticed that I like Lisp. Itellectually, that is. I don't really speak it. I finally decided to dive and try and learn it. On the surface it is not that hard - the language is extremely simple, essentially it has brackets and white space as separators, a couple of special forms - something like built in functions or language constructs in other language terminology, and a few really cool features like quote, unquote, quasiquote, (precious special forms actually), oh, yes, it has an eval.
In order to go forward with the learning I shall try and implement a simple web-design friendly template for xml applications. The idea is similar to TAL, or taglibs, etc...
Problem
A template is a valid xml document with namespaces. Some, not all, namespaces have programmatic meaning, that is they should be interpreted by an application. A template engine should be able to read an xml document and execute those statements encoded in xml.
Example
an XML source fragment
<cms:node-content>
<div>
<cms:node-title>
<h3><a cms:node-title-link="relative" >
<cms:node-title-text >
Sed ut perspiciatis unde omnis iste natus error sit
voluptatem accusantium doloremque laudantium, totam
rem aperiam, eaque ipsa quae ab illo inventore veri-
tatis et quasi architecto beatae vitae dicta sunt
explicabo.
</cms:node-title-text >
</a>
</h3>
.....
</div>
</cms:node-content>
This should execute cms:node-content, cms:node-title, cms:node-title-link and cms-node-title-text, which in turn perform some action. Each of the cms:* functions should know the xml context from which they are called. They might transform the underlying xml or be completely silent, being used for their side-effects.
A first draft of a scheme representation
(div
(cms:node-title
(h3
(a (cms:node-title-text Sed ut perspiciatis...)
(@ (cms:node-title-link "relative")
)
)
)
)In the above code I presume that all namespace tags have corresponding scheme functions defined. This code is a rough, simplified approximation of SXML produced s-expressions. The key is that the s-expressions should be evaluateable scheme constructs. This code might evaluate to:
<div class="node-content>
<h3><a href="Cicero/-45/de_Finibus_Bonorum_et_Malorum"
title="Cicero, de Finibus Bonorum et Malorum">
Section 1.10.32 of "de Finibus Bonorum et Malorum",
written by Cicero in 45 BC</a>
</h3>
.....
</div>The source XML fragment for all practical purposes defines a template. The idea is that a web-designer will provide a solid xhtml design, possibly with the added markup. The html file is an example rendering of that particular page, which can be filled in by a server side software. This approach is a useful double sword - designer friendly and enables programming by example, i.e a collection (union) of example renderings with the appropriate add-on markup, can be joined into a more complex, context dependent template.
Markup variation
- passtrough form - outputs its contents or doesn't modufy the program - structural html markup
- substitution form - replaces it's occurence with something else, higjer level markup - for example various widgets
- silent side-effects form - you won't guess what it is doing, by simply viewing the program/xml file, for example various counters, etc...
- substitutions with sideeffects, update the db, display the results
The above should describe what forms are needed for a decent template system.
What now?
Well, I need to dig deep and try and produce a solution, which does somethin g like this. I'll give myself a bonus point for making it simple. Another bonus point for me would be for a slim solution, this bonus point will be awarded only if the solution is readable.
