Types
-----
* add volatile types

Compile-time machinery
----------------------
* consolidate compile-time stuff into a new chapter
  - params
  - types:
    * type fns, type expressions
    * conditional and select statements on type expressions
  - compiler warning/error

Classes
-------
* add destructors description
* indicate that parentheses-less methods are statically dispatched,
  just like fields
* Consider moving methods into a new chapter, since we can have methods
  on integers or records. Consider a new cut at describing this intents.

Conversions
-----------
* how does explicit real->int conversion treat the fractional part
  (round or truncate, and in which direction)?

Expressions
-----------
* the index expressions section should also have a pointer to the
  section that defines 'this' functions (wherever that is)

* add a syntax production for index-expressions that duplicates the
  logic of call-expressions

* add param prototypes for ! operator (and other operators whose
  param versions aren't documented?)

* describe the semantics/meaning of hexadecimal real literals
  (and presumably also non-hexadecimal literals too)

Ranges
------
* should we define ranges/domains as being array-like where the
  indices serve as both indices and values?  (for the purposes of
  slicing, e.g.)


Functions
---------
* need to make sure to explain the use of default values (and
  non-lvalue default values) for inout/out/ref arguments
* move overloading and resolution subsections to the end of the section
  *** this should be true after first class function stuff is removed.
* define semantics of creating tuples with array components, etc.
* define function resolution for type functions (perhaps by difference from
  resolution for regular functions)
  ** insert a reference to that in the Generics' Type Constructor section
* rename "function" to "procedure" throughout the spec; add the "non-iterator"
  specifier (where appropriate), which was removed in r18389/r18390;
  perhaps also add the "non-method" specifier, at least at the top
  of the Procedures chapter


Domains and Arrays
------------------

* clarify distinction between sparse domains and associative domains
  of integers?

* clarify distinction between rank-change slice and non- (e.g.,
  A[1..n, 2] vs. A[1..n, 2..2].  See "Array Slicing etc" email from
  Damian McGuckin date Jan 28th, 2011 and references to 19.11 and 20.6.

* summary implies that an associative domain is the same thing as a
  domain?

* better example of promotion than domain assignment of domain to
  array?  (see mail with Michael Ferguson)

* better array slicing example (see mail with Michael Ferguson)

* note that array slicing doesn't result in a renumbering of the array
  -- global indices are preserved -- contrasts with Perl, Python

* define "indexing promotion" as in this case:
    var B, C: [1..3] int;  B[C] = 1..3;
  is equivalent to:
    forall (c, r) in (C, 1..3) do B[c] = r;
  (need range promotion as well)


* zippered vs. tensor indexing

TODOs from email:

- last sentence of 23.3.1 : "If there are conflicting distributions"
  This should be narrowed to only apply to zippered products I
  believe.


Data Parallelism
----------------
* clarify what it means to say that a forall loop is serializable.


Generics
--------
* add mention of the new 'depth' argument for compilerWarning/Error

Input and Output
----------------
* show file constructor or at least mention that the default constructor
  exists
* show default values for fields of file
* examples showing how to open and close a file

Task Parallelism and Synchronization
------------------------------------
* make clear that 'begin' creates task immediately and does not
  evaluate some/all of the statement that follows it
* make clear that stack variables can outlive parent scope in the
  presence of begins that escape

Standard Modules
----------------
* document logBasePow2() in Math.chpl (if we want to keep it)
* in Sort module, add definition that < is used to do the sort.
* add description of List module such as it is
* we should promote SysCTypes.chpl to an official module and unify it with
  other C types (float/double)



TODOs while updating the CHANGES file
-------------------------------------
* document the Containers module
-------------------------------------

* Make supported parameter and type queries for ranges, domains, and
  arrays more explicit in the spec.  Most users are only realizing
  that this is possible by reading example codes.  Maybe include as
  part of the "supported functions" sections for these concepts?

* page 100: 1D arrays can be indexed with square brackets or parens;
  shouldn't any rank array be indexable with either?

This may be stated as is because A(1..3, 1..3) would currently return
the 2D slice rather than a 1D array whereas A[1..3, 1..3] returns the
same thing but it is correct in that case.  This is because we don't
use promotion to implement this (and we shouldn't) but that means the
square brackets are currently ignored.  I didn't make any changes here
yet.

* refactor/rewrite domain/array chapter (Brad)

* add description of local block

Is this a good idea?  I don't understand the semantic guarantees we
can make for this construct in the presence of optimizations...

* describe how to specify a homogeneous varargs type (e.g., x: int...n)?

These are orthogonal.  I added an example.

* add const intents to spec and define default intents in terms of const
  intents (and "by reference" for arrays/domains):

  Steve's definition of const intents:
  - scalars: copy in and disallow modification
  - classes: copy reference in and disallow modification to reference
  - records: copy in and disallow modification
  - domains/arrays: pass by ref and disallow modification

  Brad's mental definition had been the same except:
  - records: pass by ref and disallow modification

  Joint definition of default intents:
  - scalars, classes, records: same as default:
  - domains/arrays: pass by ref and allow modification

* Does spec talk about declaring methods for types other than
  classes/records?

* Document +, - on domains

* do we document that argument names must match for dynamic dispatch to apply?

* did we document the instantiation point of functions that are only
  instantiated via dynamic dispatch (14070)

From meeting when David was here Sep 2008
=========================================

cleanups
--------
* iterators and promotion chapter -- unify
  - define "promoted expr"
* distributions text

updates/changes
---------------
* add 'delete'
* rename 17.5.1
* range promotion
* ranges with opposite-signed strides slicing comment -- check for accuracy
* remove 1D cases from high/low function definitions
* tease "members" apart from "predefined fns" in ranges/domains/arrays
* arr.domain -- fix return type
* return iterators from functions text (or don't expose to user?)
* describe the default distributions
* local block
* 17.8 top-level content

=========================================
