3) The recursion is finite or needs to be finite. In the case of XML
and XSLT the finiteness is defined by the depth of the XML nodes that
are being traversed recursively. In the case of functions it is some
condition that breaks the recursion.

 There are no technical or practical reasons why a transformation
should not be unlimited in time.

 People are seriouly considering XSLT transformations that implement
fundamenal (and non-stop) server-side logic.

If one can have such applications implemented in the impertive style,
nothing can prevent them from being implemented in the funtional
style. There have been HTTP servers written in Haskell and that's OK.

--
Cheers,
Dimitre Novatchev
---------------------------------------
Truly great madness cannot be achieved without significant intelligence.
---------------------------------------
To invent, you need a good imagination and a pile of junk
-------------------------------------
You've achieved success in your field when you don't know whether what
you're doing is work or play

Thanks to everyone for your replies on visualizing recursion. I will
take some time to read everyone's replies.

I feel that knowing the characteristics of a recursive function / XSL
template makes it
easier to write them.

At the simplest level those characteristics are

1) A recursive template/function calls itself

2) The call to itself is at the end of the function

3) The recursion is finite or needs to be finite. In the case of XML
and XSLT the finiteness is defined by the depth of the XML nodes that
are being traversed recursively. In the case of functions it is some
condition that breaks the recursion.

At the next level of complexity, would be one function or template
calling another recursively and many other variations of the above
simple case.

-Rashmi