This is a living document - delete things when done. Avoid discussion.
-Current version (Jamison Creek)
-- more operators: and then, or else, if else
-- global consts
+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 or variable fields
- - initial value
+ - 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)
- - [] can apply to anon array field
- - anon struct field gets fields interpolated
+ 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
-Next version ??
+ - 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]
-- yet more operators
-- split values so I can have an array of just the value (1 byte for u8)
-- integers, unsigned, bitfield, float
+ 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
- - overloaded or pure
+ - pure, loaded, overloaded, augmented
+ - owned: once, counted, collected
+ - shared or thread-local
- array slice
-- char, string search
+- 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.
-Much later
+- 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
+- enum / set
- classes
-- imports and exports
-- closuers, threads, co-routines
+ - 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?
\ No newline at end of file
code / ocean-D / blobdiff