X-Git-Url: https://ocean-lang.org/code/?p=ocean-D;a=blobdiff_plain;f=00-TODO;h=e3ef707a62c062fde45f61cf416f85b5e13c9c52;hp=56d26e39cb03bff4a43ccfb498fccc08b1a5c3f3;hb=HEAD;hpb=eceb0a08424f3129775dfccc6de1a5f7f5b98d0a diff --git a/00-TODO b/00-TODO index 56d26e3..e3ef707 100644 --- a/00-TODO +++ b/00-TODO @@ -1,35 +1,30 @@ # This is a living document - delete things when done. Avoid discussion. -## Needs implementations - -### Current version (Cataract Creek) - -- allow global names to be used before they are declared. Assume global - if undeclared, and complain in final analysis. -- allow type names to be used before declared. Need to re-evaluate all - type sizes after parse. -- resolve the HACK of allowing assign from struct when name starts space. -- '?' 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 or intrinsic (@foo), with @new, @free, @nil and ? to test -- add [] as size-of-array -- replace [foo::] declaration of array with [] - fix all main() calls +## 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 + 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 -- array access to read bytes from strings. How to get length? "?string[4]" ?? - array[] gets length?? +. 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 +### 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 @@ -51,8 +46,103 @@ - '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 ?? @@ -62,17 +152,30 @@ - '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 - + handled - accesses convert to function calls?? constant - compile time constant - not stored stable - ?? @@ -92,7 +195,7 @@ 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 @@ -147,6 +250,16 @@ NO - pattern matching for destructuring?? 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