updates

[ocean-D] / 00-TODO

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

## Needs implementation

### Next Version (Govetts Creek)
- split base_prototype into num/bool/str/label/none
- int nat cyc {i,n,c}{8,16,32,64} - maybe not cyc - it needs size.
- ops: # & | ~ &~  - 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"
  Maybe .true and .false for Boolean.
- change use/case labels to create a local enum if no type is evident.
- set, with bool or int members.  set foo { pinned, memalloc, priority(4) }
  bar:foo = .memalloc | .priority(2). if bar.pinned: bar.priority += 1
. array slices - references to arrays  "foo: []bar"
- array access to read bytes from strings. array[] gets length
- remove 'use', replace with 'select' for non-bool and 'continue' for bool and "return" for function
- "return" should convert a referenct to a reference if needed.
- remove all tests on type->functions
- use a type->function for performing function call
- revise all commentary
- blog post
- release

### Subsequent version - Nepean River ??
- Maybe allow a reference to be passed to function where the by-value is expected
- 'return' statement similar to 'use', but only valid a function context
- 'return' can take no value when function has inline/transparent return value
- simple methods.  Define "func type.name...." and the name will only be visible
  within namespace for type.
- 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 if attribute 'open'
   do I need attribute?  Can anything be type compatible with both X and []X ??
- initial values for return parameters
- convert between string and array-of-cyc8
- float64 float32
- transparent fields, parameters which are structs or pointers
- transparent fields which are arrays
- transparent results from functions to have same effect as inline-results
- manifest values for records: [.foo = a, .bar = b]
- manifest values for arrays: [expr = expr, ...]
- constant structure definitions
- const structures can inherit from another, and update select fields.
- 'use' labels *must* appear in case statements.
- '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.

- Finalize what a "main" program looks like.
   should argv come from a library (sys.argv), or should environ go to main?

- classes
   - constructors and destructors - or "after" ??
     destructors, which can be declared inline
   - vtables, fat pointers, list of approaches
- interfaces, inheritance
- 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 ??
NO - pattern matching for destructuring??
- casts to and from "binary".
NO- typeswitch?
- ??? algebraic types

- code can appear in multiple forms:
   - source code
   - abstract syntax tree
   - byte-code
   - loadable machine code
   - executable-only machine code
  All but last can be loaded by 'ocean' and transformed into a later form,
  or executed directly.  byte-code and loadable machine code will likely 
  have ast content was well to describe types and provide template code.

## Needed in library
 - augmented and overloaded pointers
    An augmented pointer can also store a flag- for a bitlock etc
    An overloaded pointer can alternately store an int - e.g. error code
 - garbage collection?
 - 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?