Should we have a keyword to specify self is mutable in function signatures

[JSAbrahams]

Current Issue

Ideally we want in functions to be able to define whether self is mutable or not.
Currently, the default is that it is mutable, and if we want self to be final then we have to add fin.
E.g:

def f(fin self, a, b ....)

However, by default users will most likely always have self be mutable (by not appending fin).
This is fine, until we have a final variable and try to access its methods.
Then, the compiler will constantly throw errors because self will most likely be mutable (even when it needn't be).
Instead, we want that self is final by default and only mutable if the user explicitly defines this.
This falls along the line of the philosophy of "strict, but as familiar as possible to those coming from Python.
So then we would have the following:

class MyClass
    def c: Int := 10

    def f(self, a) -> Int =>
        a + b

    def g(mut self, a) -> Int =>
        self.c += a
        a + b

def my_class := MyClass()

my_class.f(10)
my_class.g(10)

def fin my_class := MyClass()
my_class.g(10) # gives error!

A few issues here is that:

• We introduce yet another keyword.
• The keyword fin and mut are relatively similar and might be weird to use them both.
  The main reasoning is that:
  • fin is used in contexts where mutability is generally the default
  • mut is used in contexts where non-mutability is generally the default
    However, this may be seen as too much hand-holding.
    The issue, as I see it, is that in my experience mutability in modern "strict" languages is the exception, and not the other way around.

High-level description of the feature

• Re-add mutable keyword mut, which may only be used in function signatures.

Description of potential implementation

• Add to token to parse stage.
• Change behavior of check slightly to deal with new token.

[JSAbrahams]

I'm leaning towards not doing this, but I'll leave this hear until we reach this milestone.
The main reason for not doing this would be that we should in functions stick to the same philosophy as top-level scripts.
My main gripe is that for many applications you don't need everything to be mutable, so having to put fin constantly in signatures is a bit cumbersome and may lead to it not being used.

In top-level scripts, I'm just leaving the behaviour as-is anyway because I'm assuming most variables need to be mutable there.
We could also use the var val system from Kotlin and Scala (?).
Would be a bit sad since I did like that we use def for everything, which feels more math-like.

[JSAbrahams]

After giving this a bit more thought, I think it's best to not compromise with the philosophy of Mamba.
We should reintroduce the 'mut' token and remove the 'fin' token.
By default everything is immutable.
This will slightly increase the learning curve of the language for those coming from Python.
But I'd rather that be the cause than Mamba become a Frankenstein language.