# This is a living document - delete things when done. Avoid discussion.
-## Needs implementations
-
-### Current version (Cataract Creek)
-
-- reference to struct or intrinsic (@foo), with @new, @free, @nil and ? to test
-- allow passing objects to functions by reference is requested
-- add [] as size-of-array
-- replace [foo::] declaration of array with [] - fix all main() calls
-- ensure all param passing and value return is handled correctly
-- revise all commentary
-- blog post
-- release
+## 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=
-- make '.' modifier interpolate a deref if needed
- 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 in ".name" which creates a local enum if no
- type is evident.
+ 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. How to get length? "?string[4]" ??
- array[] gets length??
+- 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
+### 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
- '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.
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 ??
- '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
-- 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
+ 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
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
code / ocean-D / blobdiff