+- 'then' can extend a case section into some other.
+
+### And then ...
+- constructors(called by @new) and destructors (called by @free)
+- "?type" which includes an error flag in the type
+- interfaces - with syntax for function type declarations, including
+ type parameterisation
+- const arrays that are extended incrementally
+- enums that are extended incrementally
+- enum as array index. foo:[:enum]int. foo[.baz] = 23
+- modules - exported names in versions, and import lists
+ on types, fields, constants, etc
+- foreach variable-list := make_generator() do
+ A generator has 'first', 'next' and 'finally' methods
+ 'first' and 'next' return the same type which is conditional ('?' works)
+ 'finally' returns some other type - possibly Tnone - which goes to
+ a set of case at end of loop
+ NOTE need to understand how break/continue are handled.
+- lamba - inline functions. If possible allow a syntax that looks like 'while'...
+- "run" statement which copies things to a new frame and runs in
+ parallel. It has no 'return' value
+
+### static analysis
+- add generic attributes with rules for what values are allowed with
+ which attributes. Need to track:
+ - when object should be freed
+ - when ref is NULL
+ - when value is valid
+ - when int is in some range
+ - when object is "locked"
+ structures can have virtual 'state' fields which align with attributes
+ and certain state values imply certain attributes.
+
+### export
+- structs which have endian and are not sorted (records)
+- interface to C api (FFI)
+
+### escape
+- for an attribute
+- convert between integers and refs.
+
+### compile time reflection
+- code that can interpret attributes etc??
+
+## Needs Design
+- review {} syntax issues - look at weird test cases
+- do I need a 'rune' type? What are the elements of a string?
+ Are they small strings? Can I convert to codepoint by treating as number?
+ How much of this is in the utf8 library? Can a string literal be a number?
+- exactly where does auto enref/deref happen?
+ .foo modifier does auto-deref
+ (args) modifier does auto-deref (if that makes sense)
+ assignments does auto-enref
+ function parameter passing does auto enref and auto deref
+
+ general operators? Not comparison. Not test. Probably not anything.
+
+- can "A if B else C" have "A" and "C" be different - one a ref and one not?
+ This might make sense if a ref was wanted - an lvalue is then accepted.
+ But then the ref can have '@' applied so it becomes an lvalue. So "no".
+
+- ? modifier for type makes "no such value" an option, detected by '?' operator
+- $ operator to convert to ?number from ... ref? enum?
+ ?$"hello" can test if the conversion would work. '$foo ?? default'
+ provides a default value
+- a suffix on a number/string can provide soft typing which is interpreted
+ in type context. Must like .enumvalue is interpreted only the context of
+ expected type, '43i' would only be meaningful in the same context.
+- const arrays that are initialized incrementally throughout the code,
+ and post-processed at compile-time, e.g. to sort or derive LR tables.
+ Maybe even across modules.
+ Need a syntax
+ Maybe 'const' can be followed by name of a const which forms the namespace.
+ So a struct bar containing x and y could be initialized
+ const foo::bar
+ x ::= 1; y::=2
+ Then an array could be extended with [+]
+ const ra[+]
+ x::=2 ...
+
+ The syntax needs to be clearly different from
+ const a::num=1; b::=2
+ if that is still allowed
+ Maybe the '=' is enough to differentiate
+
+- IN and OUT should not be completely ignored when not expected.
+ As well as causing NEWLINE to be ignored, there should be some
+ balance requirement. Some productions should be required to be
+ balanced. Lists should not have gratuitous indents.
+ Revisit everything I considered before, but now consider it only
+ for ignore IN/OUT.
+
+- "debug" code that can be compiled out. For code, "if debug" is enough
+ if the const can be set easily. For structure members a 'debugonly'
+ attribute needs to be handled. Of course 'debug' is multifaceted.
+ We might want tracing, consistency, profiling, etc.
+
+- union types - how do I want to support these? inheritance with variance?
+- how are mixins represented?
+- lambda
+- 'error' value for various types. NIL for pointer NaN for float, extra flag bit
+ for integers. -MAX_INT ??
+- enum as array index. foo:[:enum]int. foo[.baz] = 23
+- init_only fields
+- const fields in structs: like const, but in 'type' namespace, not 'module'
+- 'borrowed' and 'owned' attributes for pointers. .free method
+- interfaces - list of methods that must be defined
+- standard interfaces to access operations: group, field, binary, logical
+ How is compatibility of type for second argument assessed?
+ For integers we allow upgrading or even down-grading??
+ This is for overloading operators. Can we combine them?
+ * / % + - neg abs
+ and or not
+ ++ ?? ?
+ []
+ () (funcall)
+ if/else
+ < <= > >= == !=
+ # & | ~ &~
+
+ I think and/or/not/if-else/??/? cannot be overloaded
+ Can '?' be used to mae booleans of anything? How does that
+ interfere with jusing it to test a reference?
+ i.e. how do a query an object when I have a ref?
+ "compare" can, but it is one operator with aliases. or maybe 2, eql and cmp
+ ++ [] definitely can be overloaded though [] need to know if assignment or access
+ assignment?? Can that be overloaded i.e. trigger on access.
+ () can be redirected via 'transparent' function member
+
+- attributes for fields and local variables
+ transparent - names inside can be accessed directly
+
+ handled - accesses convert to function calls??
+ constant - compile time constant - not stored
+ stable - ??
+ add-only - ?? like append-only.
+ read-only - set early never changed?
+ mutable
+ owned - Can be borrowed and freed
+ borrowed - There is somewhere this is borrowed from
+ dependant - ???
+ pure - definitely not an error
+ endian(big,small,pdp)
+ attributes for whole struct
+ unsorted - fields appear as written
+ packed - like unsorted, but no gaps permitted.
+
+- lambda functions for passing as arg to function.
+ Are these always there to provide an interface for a value?
+ Do I want a syntax for functions that just provides a value
+ func (a:number; b:string):number = a+b[]
+
+- units for numbers
+- iso suffixes for number?
+- static variables. Easy to implement, but need a syntax. Something
+ really loud.
+- concurrency
+ implicit and explict
+ reference attributes for locks and refcounts etc
+ RCU
+ - do/go/run/fork/async complex statement
+ All local variables accessed in the body are read-only
+ and copied to a new frame, and code is run in a new thread.
+ Thread is mostly invisible. It interacts through shared objects,
+ particularly the caller might create a channel and the thread
+ might send messages on it. Any interesting handshakes
+ are mediated by appropriate data structures.
+
+- arbitrary value asserts tied to variable attributes.
+ e.g. ranges for value and relationships between fields
+ These are tested by compiler at any changed. Somehow.
+
+- 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.