xsl-list
[Top] [All Lists]

Re: [xsl] Best practice for typing?

2019-11-23 20:15:19
Dear Dimitre, Pieter, and Michael,

Thank you all for the informative and helpful responses!

Best,

David

On Sat, Nov 23, 2019 at 2:18 AM Michael Kay mike(_at_)saxonica(_dot_)com <
xsl-list-service(_at_)lists(_dot_)mulberrytech(_dot_)com> wrote:

Declaring the type on xsl:param is always good practice.

Declaring the type on xsl:variable is also good practice, though I don't
tend to bother if it's obvious, e.g. <xsl:variable name="x" select="12"/>.

Declaring the type on xsl:with-param can be useful documentation for
someone reading the code, in cases where the type isn't obvious, but it's
not something I regard as important.

Declaring the return type on functions and templates is also good
practice; I always do it for functions, but I tend not to bother for
templates if they are constructing new elements, since that's usually
obvious.

In Saxon, I think the only case where declaring a type is likely to incur
a significant run-time cost is with maps: checking that a map conforms to
its declared type can be expensive, though Saxon does try to keep track of
the type information through map modifications in many cases. By contrast,
providing type information can sometimes enable very worthwhile
optimizations. For example with the expression $x/firstName, it's very
useful to know statically that $x is a single node: this not only avoids a
run-time check, it can also avoid a sort operation (but actually, we should
get into the habit of writing this as $x!firstName instead). Similarly with
xxx[$i] it is very useful to know in advance that $i is an integer.

Michael Kay
Saxonica

On 23 Nov 2019, at 01:44, David Birnbaum djbpitt(_at_)gmail(_dot_)com <
xsl-list-service(_at_)lists(_dot_)mulberrytech(_dot_)com> wrote:

Dear xsl-list,

Is there a consensus about best practice with respect to possibly
redundant typing? For example, we can specify a type using @as on
corresponding <xsl:param> and <xsl:with-param> elements, but if the type is
specified on <xsl:param>, it seems as if that might make it redundant also
to specify it on <xsl:with-param>, since using the wrong type at the level
of <xsl:with-param> will be caught by the type specification on <xsl:param>
anyway. Similarly, if I construct the return value of a function by using
<xsl:sequence> inside the body of the function, I can specify the typing on
<xsl:sequence>, but also on <xsl:function>, and it seems as if specifying
it in either of those places will catch the same errors as specifying in
both. (I am only beginning to learn to use schema-aware processing, and
therefore less certain about how specifying @type when constructing an
interim element or attribute interacts with specifying @as when using it.)

Is there consensus among XSLT developers about whether it might be better
to use @as everywhere it is allowed, or, alternatively, better to avoid
using it redundantly? What is the practice of other readers of this list?

Thanks,

David
djbpitt(_at_)gmail(_dot_)com
XSL-List info and archive <http://www.mulberrytech.com/xsl/xsl-list>
EasyUnsubscribe <http://lists.mulberrytech.com/unsub/xsl-list/293509> (by
email)


XSL-List info and archive <http://www.mulberrytech.com/xsl/xsl-list>
EasyUnsubscribe <http://lists.mulberrytech.com/unsub/xsl-list/3318727> (by
email <>)

--~----------------------------------------------------------------
XSL-List info and archive: http://www.mulberrytech.com/xsl/xsl-list
EasyUnsubscribe: http://lists.mulberrytech.com/unsub/xsl-list/1167547
or by email: xsl-list-unsub(_at_)lists(_dot_)mulberrytech(_dot_)com
--~--
<Prev in Thread] Current Thread [Next in Thread>