XML challenges to programming language design

XML challenges to programming language design XML challenges to programming language design

Per Bothner

What this talk is about

Constructing XML Elements

XSLT and JSP use XML syntax for both logic and creating XML. (Verbose, hard-to-read.)
XQuery uses functional syntax for logic, and XML syntax for element construction. (Less integrated.)
In the Lisp world, we can use S-expressions (SXML). (No dynamic validation or static typing.)
LAML maps each HTML tag to a mirror function with the same name.
Calling a mirror function generates a node object.

Constructor functions

Short-hand syntax for defining new constructors functions:

(define-element html (head body))
(define-element body any) ;; if lazy

Namespaces

XML namespaces are similar to Common Lisp packages.
Even uses same syntax: prefix:local-name
However, namespace is just a URL string.
Namespace declarations map prefix to a URL.
Namespace declarations can be lexically nested
(hence must be done after read-time).

(define-namespace html "some-unique-string")
(html:html (html:body (html:p "Hello")))

Attributes

(html:a href: "http://gnu.org/" "GNU")

Sequences as multiple values

Sequences versus lists

Non-nesting sequences handle common case easier:
list, cons, append are combined.
Non-nesting sequences may be easier for beginners.
E.g. a char and a one-char string are the same.
Symmetry between parameter list and result sequence.
Integrates expressions and statements.

Arrays

Expressions and Statements

A Scheme <body> is one or more expresions.
Its value is that the of last expression.
Instead, make value of <body> be concatenation of values of sub-expressions.
Define define, set! etc to return zero values.
If we really need to discard result, use explicit discard.

Sequence Comprehensions

(define x
  (let r ((i 0)) ;; R5RS "named let"
    (+ 100 i)
    (if (< i 5)
      (r (+ i 1)))
    i))

evaluates to:

100 101 102 103 104 105 5 4 3 2 1 0

Application: GUI constructors

Mozilla's XUL and Microsoft's XAML let you lay out GUI applications using XML to describe nested widgets.
Easy to use, less verbose than Java/C#.
Integrates poorly with event handlers, awkward repetition.
Attributes and children are literal, not calculated.
Element constructors have same benefits and solve problems.

Example: a button bar

(do ((i 1 (+ i 1)))
    ((> i 10))
  (button
     label: (number->string i)
     onpress: (lambda () (handle-digit i))))

Functions and Patterns

Indentation

Nice to use parentheses for grouping rather than application, as in ML etc.
Also nice to use juxtaposition for sequence concatenation; avoid noise syntax in input not in output.

fun1 a b c
       fun2 d e
       fun3 f

-->

(fun1 a (b c)
        (fun2 d e)
        (fun3 f))