We finish our coverage of higher-order functions with a number of examples from the web domain.

18.1.  HTML mirror generation
Contents   Up Previous Next   Slide    Subject index Program index Exercise index 

In this section we will, in a principled way, show how to generate simple HTML mirror functions in Scheme. Please notice that the HTML mirror functions in LAML are more sophisticated and elaborate than the ones discussed here.

The higher-order functions generate-double-tag-function and generate-single-tag-function are the top level functions. They rely on a couple of other functions, which we program in Program 18.2 - Program 18.4.

1
2
3
4
5
6
7

(define (generate-double-tag-function tag-name)
  (lambda (contents . attributes)
    (double-tag tag-name contents attributes)))

(define (generate-single-tag-function tag-name)
  (lambda attributes
    (single-tag tag-name attributes)))

1
2
3
4
5
6
7

(define (single-tag name attributes)
 (start-tag name attributes))

(define (double-tag name contents attributes)
 (string-append (start-tag name attributes)
                (as-string contents)
                (end-tag name)))

The functions start-tag and end-tag are used in Program 18.2 and implemented in Program 18.3.

1
2
3
4
5
6
7
8

(define (start-tag kind attributes)
  (if (null? attributes) 
      (string-append "<" kind ">")
      (let ((html-attributes (linearize-attributes attributes)))
         (string-append "<" kind " " html-attributes " >"))))

(define (end-tag kind)
  (string-append "</" kind ">"))

The missing aspect at this point is the attribute handling stuff. It is made in Program 18.4.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

(define (linearize-attributes attr-list)
  (string-append  
    (linearize-attributes-1
      (reverse attr-list) "" (length attr-list))))

(define (linearize-attributes-1 attr-list res-string lgt)
  (cond ((null? attr-list) res-string)
        ((>= lgt 2) 
          (linearize-attributes-1 
           (cddr attr-list)
           (string-append 
            (linearize-attribute-pair
             (car attr-list) (cadr attr-list)) " " res-string)
           (- lgt 2)))
        ((< lgt 2) 
          (error "The attribute list must have even length"))))

(define (linearize-attribute-pair val attr)
  (string-append (as-string attr)
                  " = " (string-it (as-string val))))

Recall that property lists, as passed to the function linearize-attributes in Program 18.4 have been discussed in Section 6.6.

There are several things to notice relative to LAML. First, the HTML mirror in LAML does not generate strings, but an internal representation akin to abstract syntax trees.

Second, the string concatenation done in Program 18.1 through Program 18.4, where a lot of small strings are aggregated, generates a lot of 'garbage strings'. The way this is handled (by the render functions in LAML) is more efficient, because we write string parts directly into a stream (or into a large, pre-allocated string).

You will find more details about LAML in Chapter 26 and subsequent chapters.

18.2.  HTML mirror usage examples
Contents   Up Previous Next   Slide    Subject index Program index Exercise index 

Let us now use the HTML mirror generation functions, which we prepared via generate-double-tag-function and generate-single-tag-function in Section 18.1.

As noticed above, there some differences between the real LAML mirror functions and the ones programmed in Section 18.1. The functions from above require string appending of such constituents as the three tr element instances in the table; This is inconvenient. Also, the mirror functions from above require that each double element gets exactly one content string followed by a number of attributes. The real LAML mirror functions accept pieces of contents and attributes in arbitrary order (thus, in some sense generalizing the XML conventions where the attributes come before the contents inside the start tag). Finally, there is no kind of contents nor attribute validation in the mirror functions from above. The LAML mirror functions validate both the contents and the attributes relative to the XML Document Type Definition (DTD).

(let* ((functions
         (map generate-double-tag-function 
              (list "table" "td" "tr")))
       (table (car functions))
       (td (cadr functions))
       (tr (caddr functions)))
 (table
  (string-append
   (tr 
     (map-concat td (list "c1" "c2" "c3"))
     'bgcolor "#ff0000")
   (tr
     (map-concat td (list "c4" "c5" "c6")))
   (tr
     (map-concat td (list "c7" "c8" "c9"))))
  'border 3))

<table border="3">
   <tr bgcolor="#ff0000">
     <td> c1 </td>
     <td> c2 </td> 
     <td> c3 </td>  
   </tr>
   <tr> 
     <td> c4 </td> 
     <td> c5 </td>
     <td> c6 </td>
   </tr>
   <tr> 
     <td> c7 </td>
     <td> c8 </td>
     <td> c9 </td>
   </tr>
</table>

To show the differences between the simple mirror from Section 18.1 and the real mirror we will show the same example using the XHTML mirror functions in Section 18.3.

18.3.  Making tables with the real mirror
Contents   Up Previous Next   Slide    Subject index Program index Exercise index 

In the example below there is no need to string append the tr forms, and there is no need to use a special string appending mapping function, like map-concat from Table 18.1. Attributes can appear before, within, or after the textual content. This makes the HTML mirror expression simpler and less clumsy. The rendering result is, however, the same.

(table
  'border 3
   (tr 
     (map td (list "c1" "c2" "c3"))
     'bgcolor "#ff0000")
   (tr
     (map td (list "c4" "c5" "c6")))
   (tr
     (map td (list "c7" "c8" "c9")))
)

<table border = "3">
  <tr bgcolor = "#ff0000">
   <td>c1</td>
   <td>c2</td>
   <td>c3</td>
  </tr> 
  <tr>
   <td>c4</td> 
   <td>c5</td> 
   <td>c6</td>
  </tr> 
  <tr>
    <td>c7</td>
    <td>c8</td>
    <td>c9</td>
  </tr>
</table>

You might think, that the example above also could be HTML4.01. But, not quite, in fact. In HTML4.01 there need to be a tbody (table body) form in between the tr instances and the table instance. Without this extract level, the table expression will not be valid. Try it yourself! It is easy.

[How, you may ask. In Emacs do M-x set-interactive-laml-mirror-library and enter html-4.01. Then do M-x run-laml-interactively. Copy the table expression from above, and try it out. You can shift to XHTML1.0 by M-x set-interactive-laml-mirror-library and asking for xhtml-1.0-transitional, for instance. Then redo M-x run-laml-interactively. Be sure to use xml-render on the result of (table ...) to make a textual rendering. ]

18.4.  Tables with higher-order functions
Contents   Up Previous Next   Slide    Subject index Program index Exercise index 

In the context of higher-order functions there are even better ways to deal with tables than the one shown in Table 18.2 from Section 18.3.

The table expression in the last line in Table 18.3 shows how.

(define rows 
  '(("This" "is" "first" "row")
   ("This" "is" "second" "row")
   ("This" "is" "third" "row")
   ("This" "is" "fourth" "row"))
)

(table 'border 5
 (gmap
   (compose tr (gmap td)) rows))

Recall that we already have discussed the ad hoc currying, which is involved in gmap, cf. the discussion in Section 17.4.

You should consult Chapter 27 to learn about the exact parameter passing rules of the HTML mirror functions in LAML.

18.5.  HTML element modifications
Contents   Up Previous Next   Slide    Subject index Program index Exercise index 

It is often useful in some context to bind an attribute of a HTML mirror function (or a number of attributes) to some fixed value(s). This can be done by the higher-order function modify-element, which we discuss below.

The function modify-element is simple. First notice that it accepts a function, namely the element parameter. It also returns a function; In effect, it returns element with attributes-and-contents appended to the parameters of the modified element. As another possibility, we could have prepended it.

1
2
3
4

(define (modify-element element . attributes-and-contents)
  (lambda parameters 
   (apply element 
    (append parameters attributes-and-contents))))

In the table below we illustrate three examples where td, ol, and ul are modified with a priori bindings of selected attributes.

(define td1 
 (modify-element td 
  'bgcolor (rgb-color-list red)
  'width 50))

(table 'border 5 
  (map (compose tr (gmap td1)) rows))

(define ol1 
  (modify-element ol 'type "A"))

(ol1 
 (map
   (compose li as-string)
   (number-interval 1 10)))

(define ul1 
  (modify-element ul 'type "square"))

(ul1 
 (map
  (compose li as-string)
  (number-interval 1 10)))

LAML supports two related, but more advanced functions called xml-in-laml-parametrization and xml-in-laml-abstraction. The first of these is intended to transform an 'old style function' to a function with XML-in-LAML parameter conventions, as explained in Chapter 27. The second function is useful to generate functions with XML-in-LAML parameter conventions in general.

18.6.  The function simple-html-table
Contents   Up Previous Next   Slide    Subject index Program index Exercise index 

We will now show show an implementation of the function simple-html-table

1
2
3
4
5
6
7
8
9
10

(define simple-html-table 
 (lambda (column-widht list-of-rows)
  (let ((gmap (curry-generalized map))
        (td-width 
          (modify-element td 'width
                          (as-string column-widht))))
    (table 
      'border 1
      (tbody 
       (gmap (compose tr (gmap td-width)) list-of-rows))))))

18.7.  The XHTML mirror in LAML
Contents   Up Previous Next   Slide    Subject index Program index Exercise index 

In order to illustrate the data, on which the HTML mirrors in LAML rely, the web edition of the material includes a huge table with the content model and attribute details of each of the 77 XHTML1.0 strict elements.

18.8.  Generation of a leq predicate from enumeration
Contents   Up Previous Next   Slide    Subject index Program index Exercise index 

As the last example related to higher-order functions we show the function generate-leq, see Program 18.7.

The idea is to generate a boolean 'less than or equal' (leq) function based on an explicit enumeration order, which is given as input to the function generate-leq. A number of technicalities are involved. You should read the details in Program 18.7 to grasp these details.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

;; Generate a less than or equal predicate from the
;; enumeration-order. If p is the generated predicate,
;; (p x y) is true if and only if (selector x) comes before
;; (or at the same position) as (selector y) in the
;; enumeration-order. Thus, (selector x) is assumed to give a
;; value in enumeration-order. Comparison with elements in the
;; enumeration-list is done with eq?
(define (generate-leq enumeration-order selector)
  (lambda (x y)
     ; x and y supposed to be elements in enumeration order
     (let ((x-index (list-index (selector x) enumeration-order))
           (y-index (list-index (selector y) enumeration-order)))
       (<= x-index y-index))))

; A helping function of generate-leq.
; Return the position of e in lst. First is 1
; compare with eq?
; if e is not member of lst return (+ 1 (length lst))
(define (list-index e lst)
 (cond ((null? lst) 1)
       ((eq? (car lst) e) 1)
       (else (+ 1 (list-index e (cdr lst))))))

The table below shows a very simple example, in which we use simple-leq?, which is generated by the higher-order function generate-leq from Program 18.7.

(define simple-leq? 
  (generate-leq '(z a c b y x) id-1))

(sort-list '(a x y z c c b a) simple-leq?)

(z a a c c b y x)

The fragment in Program 18.8 gives a more realistic example of the use of generated 'less than or equal' functions. In Program 18.9 we show how the desired sorting of manual-page subelements is achieved.

1
2
3
4
5
6
7
8
9

(manual-page 
 (form '(show-table rows))
 (title "show-table")
 (description "Presents the table, in terms of rows")
 (parameter "row" "a list of elements")
 (pre-condition "Must be placed before the begin-notes clause")
 (misc "Internally, sets the variable lecture-id")
 (result "returns an HTML string")
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

(define (syntactic-form name)
  (lambda subclauses (cons name subclauses)))

(define form (syntactic-form 'form))
(define title (syntactic-form 'title))
(define description (syntactic-form 'description))
(define parameter (syntactic-form 'parameter))
(define pre-condition (syntactic-form 'pre-condition))
(define misc (syntactic-form 'misc))
(define result (syntactic-form 'result))

(define (manual-page . clauses)
 (let ((clause-leq? 
         (generate-leq
           '(title form description 
             pre-condition result misc)
           first))
      )
  (let ((sorted-clauses (sort-list clauses clause-leq?)))
    (present-clauses sorted-clauses))))