Re: Best practice for typing?

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@xxxxxxxxxxxx <
xsl-list-service@xxxxxxxxxxxxxxxxxxxxxx> 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@xxxxxxxxx <
> xsl-list-service@xxxxxxxxxxxxxxxxxxxxxx> 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@xxxxxxxxx
> 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 <>)