You are looking at historical revision 2740 of this page. It may differ significantly from its current revision.

Introduction

The hart egg provides an SXML-inspired syntax for HTML generation.

(Sorry, documentation is a bit sparse at the moment.)

License

hart is licensed under the BSD License.

Authors

Graham Fawcett

Requirements

Examples

Canonical Usage

(use hart)
(define people '((Fred fred@example.net 25) (Mary mary@example.net 33)))
(hart (html (head (title "People"))
            (body (h1 (fmt: "A list of ~a people" (length people)))
                  (if: (null? people)
                       (h2 "No people!")
                       (ol (for: ((name email age) people)
                             (li (a (@ (href (conc "mailto:" email)))
                                    (text: name))
                                 (fmt: ", who is ~a years old." age))))))))

which produces

<html><head><title>People</title></head><body>
<h1>A list of 2 people</h1>
<ol><li><a href="mailto:fred@example.net">Fred</a>, who is 25 years old.</li>
<li><a href="mailto:mary@example.net">Mary</a>, who is 33 years old.</li>
</ol></body></html>

Syntax

[syntax] (hart hart-expr)
[syntax] (hart->string hart-expr)

Compiles hart-expr, an expression in the Hart syntax. In short, Hart is SXML syntax plus a set of "keyword expressions" which handle flow-control, iteration, escaping, etc.

(hart) outputs to (current-output-port) and returns an undefined value. (hart->string) returns a string value.

Keyword expressions

[syntax] (if: expr hart-true hart-false)

Like an (if) expression, except hart-true and hart-false are expressions in Hart syntax.

[syntax] (for: (iter-expr list-or-vec) hart-body*)

A looping construct. The iter-expr is a match-expression which is matched to each successive value in list-or-vec. Hart-body is a Hart expression which is evaluated for each value of iter-expr.

[syntax] (let: let-forms hart-body*)

Like a (let ...) expression, but hart-body is a Hart expression.

Formatting keywords

[syntax] (raw: expr*)

The Scheme expressions (not Hart!) are evaluated to strings and outputted, without HTML/XML escaping.

[syntax] (text: expr*) or (t: expr*)

The expressions are evaluated to strings, HTML-escaped, and outputted.

[syntax] (fmt: format-string args*)

The result of (format format-string args*) is HTML-escaped and outputted.