[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]


I'm not a conformance expert, but this seems basically okay to me.
I just have a couple of criticisms.  Indented text is excerpted from
your message.

  Extensions to syntax are not allowed in conforming code.

This is ambiguous.  It could be read to mean that conforming code is not
permitted to define reader macros.  However, what I think you meant is
that conforming code is not permitted to depend on
implementation-provided syntax extensions.  Is that what you meant?
How is that different from:

  1. Conforming code uses only the syntax specified in the standard.

In fact, that statement might also be read to rule out definition of
reader macros by conforming code.  You should treat syntax the same
as functions, macros, etc., i.e. conforming code must use only the
things defined in the standard plus things whose definition accompanies
the program, where "things" includes syntax as well as defined names.

  6. Conforming code will only be defined in terms of its structure.

as contrasted with what?  Its behavior?  Say explicitly.
Perhaps the whole "informal rules" section needs a little more writing
to use more parallel constructions and avoid ambiguities and loopholes.
Even though it's informal it should not be ambiguous.

  Portable code is required to produce equivalent results and 
  observable side effects in all conforming implementations.   
  Portable code is written using only STANDARD-CHAR-P characters.
  Portable code is written using no extra optional keyword arguments.

The term "portable" is never defined.  Is this a definition?  (In which
case move it to the definitions section earlier in the proposal.)  If this
is not a definition, but a restriction on something whose definition is
different, add an explicit definition.  Also I don't understand what the
last sentence about "extra optional keyword arguments" is supposed to
refer to, nor how portable and conforming code differ in this respect.

  The standard must contain information about conformance. Only including 
  requirements that would be placed on implementations, however, leaves
  the possibility open that something would be overlooked, and so 
  implementations may well conform without processing correctly
  conforming code. 

Sorry, I couldn't understand the second sentence at all.  I couldn't
even parse it.