unusual let binding (of lp) - in function element->xml from sxml simple

[Andreas Reuleaux <rx@a-rx.info>]

Hi,

I have a hard time understanding the let binding lp ...
in the function element->xml - from module sxml simple -
repeated here for convenience.


--8<---------------cut here---------------start------------->8---
(define (element->xml tag attrs body port)
  (check-name tag)
  (display #\< port)
  (display tag port)
  (if attrs
      (let lp ((attrs attrs))
        (if (pair? attrs)
            (let ((attr (car attrs)))
              (display #\space port)
              (if (pair? attr)
                  (attribute->xml (car attr) (cdr attr) port)
                  (error "bad attribute" tag attr))
              (lp (cdr attrs)))
            (if (not (null? attrs))
                (error "bad attributes" tag attrs)))))
  (if (pair? body)
      (begin
        (display #\> port)
        (let lp ((body body))
          (cond
           ((pair? body)
            (sxml->xml (car body) port)
            (lp (cdr body)))
           ((null? body)
            (display "</" port)
            (display tag port)
            (display ">" port))
           (else
            (error "bad element body" tag body)))))
      (display " />" port)))
--8<---------------cut here---------------end--------------->8---

Some background: sxml simple is - as the name implies -
simple (or should be so). - It's implements

* functions for parsing xml to s-expression
  xml->sxml, ...

* and functions for serializing sxml to xml
  sxml->xml, ... (and among them: element->xml, as above)

This second task (group of functions) is even simpler
(than the parsing stuff) - I would say.

Now these function (sxml->xml, element->xml) work for
me: I can test them with some simple s-expression foo for example

--8<---------------cut here---------------start------------->8---
(define foo
  '(d:para (d:emphasis (@ (role "strong")) "system analyst") " for " (d:link (@ (xl:href "http://www.blah.com")) (d:emphasis (@ (role "strong")) "Blah")) " in Berlin, and so on"))
--8<---------------cut here---------------end--------------->8---


--8<---------------cut here---------------start------------->8---
scheme@(guile-user) [13]> (sxml->xml foo)
<d:para><d:emphasis role="strong">system analyst</d:emphasis> for
<d:link xl:href="http://www.blah.com"><d:emphasis role="strong">Blah</d:emphasis></d:link> in Berlin, and so on</d:para>
--8<---------------cut here---------------end--------------->8---


sxml->xml making use of element->xml above.
Now with regards to the binding / usage of lp above: it is
bound / used several times:


      (let lp ((attrs attrs)) ...
      let lp be a function that ... does what?


      (lp (cdr attrs)))
      now call this function with (cdr attrs).
      What does it do?
      set attrs to (cdr attrs)?


      then similar below
      (let lp ((body body)) ...
      ???


      (lp (cdr body)))
      ???


For one thing I am used to

(let bindings body)

with bindings being of the form
 ((x 'foo)
  (y 'bar))

(i.e. bind x with 'foo, y with 'bar when executing body)

for example, lp is not of this style. Maybe if there is just one variable bound
one can shortcut this to

  let x 'foo body

Is this what's going on above? And if so:
then lp is bound to a list of one pair? :

((attrs attrs))

how come can we call this as a function then later.

And if attrs is a function (which I doubt) that what
is the application of attrs to attrs?

Anyway: confused. - Thanks in advanc,
  A'