After some considerations I decided to steer away from muddy waters of improving everything related to types and objects management in one take. It does not take the genius to notice it is a vast area to cover and I will have plenty of work merging C# value and reference types with C++ mutable/const attributes with non-/nullable pointers.
This is already the challenge because with such variety of features it is easy to produce some obscure syntax. So I changed my perspective — keep it simple, make one step at a time, scratch only if it itches.
struct” is value type in Skila exactly like it is in C#. There is richer annotation though:
var x Struct = new Struct(); const y Struct = new Struct();
The first line declares a variable, thus you can change the data of “
x”. The second line declares a constant — this works like in C++, so it is logical immutability, not the bitwise one.
The same modifier can be applied when passing “
struct” to a function:
def foo(var a Struct) ... def bar(const b Struct) ...
By default the parameter data is assumed to be constant so you can drop “
const” in the second line.
The first line is more interesting — it tells you can change the data and those changes will be visible on caller side. So from caller perspective it is a side effect — it should not go unnoticed and it doesn’t:
foo(!x); bar(x); bar(y);
Those are valid calls — just like with mutating methods there is exclamation mark added as acknowledgment of alteration of “
I didn’t add ability to pass a copy of the variable which could be changed just inside the function (pass by value). Time will tell if it is needed, now I move to C# “
class” — it is a bit more problematic, because the data can be constant, the reference can be constant, and a reference can be “
null” — the syntax is just boiling over.