This is a link

with the following s-expression:

(:a :href "foo.html" "This is a link")

The other syntax FOO supports is to group the tag name and attributes into their own list like this:

((:a :href "foo.html") "This is link.")

FOO can use the s-expression representation of HTML in two ways. The function emit-htmltakes an HTML s-expression and outputs the corresponding HTML.

WEB> (emit-html '(:html (:head (:title "Hello")) (:body (:p "Hello, world!"))))

Hello, world!

T

However, emit-htmlisn't always the most efficient way to generate HTML because its argument must be a complete s-expression representation of the HTML to be generated. While it's easy to build such a representation, it's not always particularly efficient. For instance, suppose you wanted to make an HTML page containing a list of 10,000 random numbers. You could build the s-expression using a backquote template and then pass it to emit-htmllike this:

(emit-html

`(:html

(:head

(:title "Random numbers"))

(:body

(:h1 "Random numbers")

(:p ,@(loop repeat 10000 collect (random 1000) collect " ")))))

However, this has to build a tree containing a 10,000-element list before it can even start emitting HTML, and the whole s-expression will become garbage as soon as the HTML is emitted. To avoid this inefficiency, FOO also provides a macro html, which allows you to embed bits of Lisp code in the middle of an HTML s-expression.

Literal values such as strings and numbers in the input to htmlare interpolated into the output HTML. Likewise, symbols are treated as variable references, and code is generated to emit their value at runtime. Thus, both of these:

(html (:p "foo"))

(let ((x "foo")) (html (:p x)))

will emit the following:

foo

List forms that don't start with a keyword symbol are assumed to be code and are embedded in the generated code. Any values the embedded code returns will be ignored, but the code can emit more HTML by calling htmlitself. For instance, to emit the contents of a list in HTML, you might write this:

(html (:ul (dolist (item (list 1 2 3)) (html (:li item)))))

which will emit the following HTML:

• 1
• 2
• 3

If you want to emit the value of a list form, you must wrap it in the pseudotag :print. Thus, this expression:

(html (:p (+ 1 2)))

generates this HTML after computing and discarding the value 3:

To emit the 3, you must write this:

(html (:p (:print (+ 1 2))))

Or you could compute the value and store it in a variable outside the call to htmllike this:

(let ((x (+ 1 2))) (html (:p x)))

Thus, you can use the htmlmacro to generate the list of random numbers like this:

(html

(:html

(:head

(:title "Random numbers"))

(:body

(:h1 "Random numbers")

(:p (loop repeat 10 do (html (:print (random 1000)) " "))))))

The macro version will be quite a bit more efficient than the emit-htmlversion. Not only do you never have to generate an s-expression representing the whole page, also much of the work that emit-htmldoes at runtime to interpret the s-expression will be done once, when the macro is expanded, rather than every time the code is run.

You can control where the output generated by both htmland emit-htmlis sent with the macro with-html-output, which is part of the FOO library. Thus, you can use the with-html-outputand htmlmacros from FOO to rewrite random-numberlike this:

(defun random-number (request entity)

(with-http-response (request entity :content-type "text/html")

(with-http-body (request entity)

(with-html-output ((request-reply-stream request))

(html

(:html

(:head (:title "Random"))

(:body

(:p "Random number: " (:print (random 1000))))))))))

Another feature of FOO is that it allows you to define HTML "macros" that can translate arbitrary forms into HTML s-expressions that the htmlmacro understands. For instance, suppose you frequently find yourself writing pages of this form:

(:html

(:head (:title "Some title"))

(:body

(:h1 "Some title")

... stuff ... ))

You could define an HTML macro to capture that pattern like this:

(define-html-macro :standard-page ((&key title) &body body)

`(:html

(:head (:title ,title))

(:body

(:h1 ,title)

,@body)))

Now you can use the "tag" :standard-pagein your s-expression HTML, and it'll be expanded before being interpreted or compiled. For instance, the following:

(html (:standard-page (:title "Hello") (:p "Hello, world.")))

generates the following HTML:

Hello

Hello, world.

Of course, generating HTML output is only half of Web programming. The other thing you need to do is get input from the user. As I discussed in the "A 30-Second Intro to Server-Side Web Programming" section, when a browser requests a page from a Web server, it can send query parameters in the URL and post data, both of which act as input to the server-side code.

AllegroServe, like most Web programming frameworks, takes care of parsing both these sources of input for you. By the time your published functions are called, all the key/value pairs from the query string and/or post data have been decoded and placed into an alist that you can retrieve from the request object with the function request-query. The following function returns a page showing all the query parameters it receives:

(defun show-query-params (request entity)

(with-http-response (request entity :content-type "text/html")

(with-http-body (request entity)

(with-html-output ((request-reply-stream request))

(html

(:standard-page

(:title "Query Parameters")

(if (request-query request)

(html

(:table :border 1

(loop for (k . v) in (request-query request)

do (html (:tr (:td k) (:td v))))))

(html (:p "No query parameters.")))))))))

(publish :path "/show-query-params" :function 'show-query-params)

If you give your browser a URL with a query string in it like the following:

http://localhost:2001/show-query-params?foo=bar&baz=10

you should get back a page similar to the one shown in Figure 26-4.

Figure 26-4. http://localhost:2001/show-query-params?foo=bar&baz=10

To generate some post data, you need an HTML form. The following function generates a simple form, which submits its data to show-query-params: