Today I finally got rid of that dumb "Every string literal has a unique type" thing. It's a holdover from pre-constant-expression days. I nuked the code paths that used to handle it. And I discovered that this code path also handled my local variable as reference solution.
So I decided to just whack it and change that.
Now I will use "var : type = value" for variables whose type needs to be explicitly specified. And it will also be useful for members (contrast "var : type;" with "var := value;" with NSDMIs or function arguments). Speaking of which, I should look into function defaulted arguments and such again.
I've been thinking about using type & type as a tuple syntax- so you could do f() := int64 & int64 to denote a function returning a tuple. My current module export code REQUIRES that all types have a notation, and I'm not sure that's a bad thing, it's certainly motivational to fix such issues. As a pairing, I've been thinking about using | to denote a kind of language-implemented variant. One of the keys here is that the compiler can translate it into different run-time semantics. For example, if you said
f(arg : int32 | int64)
then the compiler has no obligation to differentiate them at runtime. It could also simply generate two different overloads and branch on call if necessary.
I'm also thinking about implementing something like tuple[i], as long as i is a constant expression.
Long story short, I'm a smidge burned out on modules. I've been faffing around with dependencies and implements too long.
No comments:
Post a Comment