[Bug 29984] [XSLT30] Lessen the restraint on required raising of XTSE3430 for constructs not guaranteed streamable per our rules

https://www.w3.org/Bugs/Public/show_bug.cgi?id=29984

--- Comment #6 from C. M. Sperberg-McQueen <cmsmcq@blackmesatech.com> ---
I'd like to extend MK's analysis in comment 4 a bit.  It seems to me that from
the point of view of a user concerned with interoperability and working with a
given processor P there are several distinct subclasses of (B) and (C)

(A) Stylesheets that are guaranteed streamable

(B) Stylesheets that are statically equivalent to stylesheets that are
guaranteed streamable

(B1) Stylesheets recognized by P to be statically equivalent to a stylesheet in
(A)

(B2) Stylesheets which are in reality statically equivalent to a stylesheet in
(A), but which P does not recognize as such

(C) The rest

(C1) Not guaranteed streamable, not statically equivalent to
guaranteed-streamable stylesheets, but nevertheless streamable in fact by P

(C2) Not guaranteed streamable, not statically equivalent to
guaranteed-streamable stylesheets, and not in fact streamable by P

(C3) Guaranteed streamable, or statically equivalent to same, but not in fact
streamable

Class C3 represents errors in our rules for guaranteed streamability; I hope
it's empty, and it plays no further part here.

I believe (oversimplifying slightly, in what I hope are harmless ways) that
under the status quo, if a user requests a conforming processor to process a
stylesheet S in streaming fashion, then 

  - If S is in A, P processes S in streaming fashion.
  - If S is in B1, P processes S in streaming fashion and warns the user that S
is not in A. 
  - If S is in B2, P processes S and warns the user that S is not in A. 
(Whether the processing is done in streaming fashion or not depends on whether
P thinks S is in C1 or C2; no processor will identify any stylesheet as being
in B2.)
  - If S is in C1, P processes S in streaming fashion and warns the user that S
is not in A. 
  - If S is in C2, P processes S in non-streaming fashion and warns the user
that S is not in A. 

In all cases, the user will know whether S is in A or not in A.  Depending on
how communicative the processor is, the user may also know whether S is in (B1
+ C1) or in (C2).

If I understand the proposal here, it varies very slightly in exactly one case.
 P is not required to distinguish class B1 from class A, so B1 is handled
differently:

  - If S is in B1, P processes S in streaming fashion and does not warn the
user that S is not in A.  

The user now always knows whether S is in (A + B1) or not in (A + B1).  The
user may also be able to distinguish C1 from C2 (depends on whether the
processor issues an informative message like "you call this a streaming
stylesheet?  I can't stream this!" or "streaming anyway, lucky you").

Note that under the status quo, as I understand it, two conforming processors P
and Q may disagree on some classifications but not all.

  - P knows that S is in A iff Q knows that S is in A.
  - If P places S in any of B1, C1, or C2, Q may place S in any of B1, C1, or
C2.
  - No processor can reliably distinguish B2 from C (C1 or C2); I assume that
any S not in A or B1 will go into C1 or C2, not B2.

Since if S is in A for one processor, S will be in A for any other conforming
streaming processor, under the status quo a user will always know, from using
processor P, whether processor Q is guaranteed to stream S or not.

Under the proposal here, however,  the user cannot know from using processor P
whether S is guaranteed to be streamed by processor Q or not.  If P places S in
(A + B1), S may in reality be in A, so Q is guaranteed to stream S.  But S may
in reality be in B1, in which case Q is not guaranteed to stream S.

MK says the concept of guaranteed streamability is far from pointless, but I am
not sure what work it does.  If the stylesheet is in (A + B1), the message to
the user is essentially "well, your stylesheet is either guaranteed streamable,
or I rewrote it without noticing into one that is guaranteed streamable.  If
you run into problems with a different processor, you too can rewrite it into a
guaranteed-streamable form.  Unfortunately, I can't tell you what changes
you'll need to make in order to do that; you're on your own there.  But section
19 of the spec may help."  Compared with the goals I think the status quo
achieves, this counts in my book as pretty pointless.

-- 
You are receiving this mail because:
You are the QA Contact for the bug.

Received on Thursday, 8 December 2016 02:42:02 UTC