Can be used for array size? What else?
- anonymous field - array or struct (or pointer to these)
multiple anon struct are allowed if they don't conflict
- - [] can apply to anon array field
- - anon struct field gets fields interpolated
+ 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
- - anon fields have no name before the :, so
+ - How to give attributes? just say the word?
struct foobar:
- :content
+ x:content transparent
size:number
- manifest values for arrays and structs [a,b,c]
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 for at least 4 elements with 4th set to 2.
+
- yet more operators
<< >> #
bit-ops & | ~ &~
- per-field attributes
constant, stable, add-only, read-only, mutable, owned, borrowed, dependant, pure
- records
-- enum
+- enum / set
- classes
- 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
+- 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
Then foo.method can possible follow a chain of pointers from foo to find the method.
foo might be an inode and have a pointer to a superblock, which has a
- pointer to a methods struture contains 'getattr'. Then 'foo.getattr'
+ pointer to a methods structure contains 'getattr'. Then 'foo.getattr'
transparently becomes 'foo.super.super_methods.getattr.
Question. In what circumstances is 'foo' passed as first argument?
Probably it happens by default, but some syntactic escape allows something else
to be passed. Maybe foo::something() ??
+ Or foo..something() ??
+ Maybe if type of first arg is compatible, the value before '.' is interpolated
+ unless ".." is used.
+
+ So the name after "." can:
+ - follow a pointer
+ - be field in struct/record
+ - follow a transparent field
+ - be constant in type - which includes functions.
+
+ Transparent fields add extra distance and a closer name will match first.
+ So if foo.bar and foo.baz.bar are both valid and baz is transparent, then
+ "foo.bar' gets the former - no conflict is reported. Obviously foo.bax.bar
+ gets the latter
+
+Methods can be added to values to provide required interface for passing to
+a function. This probably only works for references.
+We can specify the methods using a type which includes them, or a value
+which already has them, or individually
+Syntax might be tricky. For 'sort' I want to pass an array, and a method
+for comparing two elements of the array. I want the function to see an array
+where the element are already comparable.
+So the function declares that it needs a type
+
+ func qsort(type:comparable, target:[size::]type)
+
+function will need size of members of array, size of array, and compare function.
+ func qsort (target:[size::]type:comparable)
+
+ ra:[32]int
+ qsort(ra, :ra[].cmp(a, b) = a >= b)
+
+Same syntax could add a destructor
+
+ foo: bar .free = myfunction