This is a living document - delete things when done.  Avoid discussion.

Current version (Cataract Creek)
- _interp_exec() to accept a value*, and type, and only copy large value there.
- functions to return struct with name assignment - bare 'use'?
    struct is open-coded in header.  Later a similar effect
    could be achieved with a named struct marked 'transparent'
- '?' prefix operator returns Boolean, index operator for strings. Can be used to
   test for end-of-string
- ?? infix operator return LHS if '?' on it would succeed, else RHS
- reference to struct (@foo), with @new, @free, @nil and ? to test

Next Version (Govetts Cree)
- int nat cyc {i,n,c}{8,16,32,64}
- # & | ~ &~  - no shift: use (N * #shift) or (N / #shift)
- op=
- enum, with multi-valued names.  enum foo { yes, no, many(10) }
  bar:foo=.yes; if bar == .no... if ?bar.many: print bar.many, "items"
- set, with bool or int members.  set foo { pinned, memalloc, priority(4) }
  bar:foo = .memalloc | .priority(2). if bar.pinned: bar.priority += 1

Subsequent version
- simple methods.  Define "func type.name...." and the name will only be visible
  within namespace for type.
- array access to read bytes from strings.  How to get length?  "?string[4]" ??
- optional args for functions - if value given
- named args?  Needs to look like manifest structs
- array args - last parameter can collect all remaining as array.

And then
- float64 float32
- enum as array index.  foo:[:enum]int.  foo[.baz] = 23

Later
- string manipulation
- structs
   - const fields ... what does that mean?  Assign once as initialization?
      Can be used for array size? What else?
      'const' is wrong word.
      I want 'const' for record to be type-wide constants, like enum.  I think
      These would become read-only.  Maybe "init_only"
   - anonymous field - array or struct (or pointer to these)
      multiple anon struct are allowed if they don't conflict
      no - transparent fields!  They still have a name, but you can
      look through it.
   - [] can apply to transparent array field
   - transparent struct field gets fields interpolated

   - How to give attributes? just say the word?
	struct foobar:
		x:content  transparent
		size:number

- static variables.  Easy to implement, but need a syntax.  Something
  really loud.

- manifest values for arrays and structs [a,b,c]
    or [.foo=a, .bar=b] or [ [1]=a, [2]=b]
   That last doesn't parse easily, unless we require tags... not a good idea.
   [ .[1] = a, .[2] = b ] ?? Maybe.
   or () to group, [] for index. To (.foo=a) ( [1] = b )

   I think that last works. () might almost be optional
     .foo=a
   is an expression means a structure with a .foo field assined to 'a'
     [3] = 2
   is an array of at least 4 elements with 4th set to 2.
  Or: an expression that starts '[' is a manifest struct or array.
   It contains ',' separate list of assignments.
   Each is either ".name = expr" for struct or "expr = expr" for array
   Except that would prevent array with enum index.  Is that a problem?


- pointers
   - owned or borrowed
   - pure, loaded, overloaded, augmented
   - owned: once, counted, collected
   - shared or thread-local
- array slice
- array buffer - can be added to and grows.

- allow "do stuff" as a stand-alone statement (scope)
- 'use' labels *must* appear in case statements.
- 'then' can extend a case section into some other.

- expose parse info for editing by code run at compile time.
  This allows new attributes to be implemented in app code.
  E.g. handling bigendian fields by adding conversion functions.

Next version (Govetts Creek):
- functions and procedures
- Finalize what a "main" program looks like.

Much later
- per-field attributes
    constant, stable, add-only, read-only, mutable, owned, borrowed, dependant, pure
- records
- enum / set
- classes
   - constructors and destructors - or "after" ??
     destructors, which can be declared inline
   - vtables, fat pointers, list of approaches
- operators as interface methods
     + - * / etc make an arith interface add sub mult div
- interfaces, inheritance
- modules, imports and exports
     public(version) on types, fields etc
- closures, threads, co-routines, generators lamdas
- generics/templates.  These should be just a compile-time
  decision.  Same code can be called with suitable methods passed, or
  recompiled in the new context and then optimised.
- introspection / reflection ?
      e.g. support serialization
      find function given a string holding the name
      measure coverage, adjust based on performance metrics
      auto-create mock objects
      Is this just parsing the details in the obj file?
- FFI
- parameterised types, and dependant types
- message passing primitives
- overloading for numbers
- exceptions ??
- ensure list_head type concept can work
- "union" type ??
- pattern matching for destructuring??
- casts??
- typeswitch?
- iso suffixes for number?
- foreach?
- break/continue or "next","last" - hopefully 'use' is enough
- algebraic types

Library functions:
 - UTF8 string disection
 - search, regexp
 - cvt() interface an format() function
 - parsing: rexep? LALR? sscan?
 - buffered file IO
 - auto-growing buffer including strings
 - sockets
 - http
 - html
 - gtk? xcb?