Allow mut function parameters of primitive type

[sbillig]

What is wrong?

(#777 follow-up)

It's not currently possible to define a function that takes a mut parameter that is a primitive (number, bool, etc) type. For example:

fn example() {
  let mut x: u64 = 0
  increment(x)
}

fn increment(mut x: u64) {
  x += 1
}

This should modify the passed-in value in the calling scope. We've discussed adding the val-lang-inspired use of the & sigil to indicate mutation, which would make this more clear. Eg increment(&x)

How can it be fixed

This one's kinda complicated. The simple way would be to put all mutable integers in memory (or, better, those that are passed mutably into fns), so that we can pass a pointer into a function so that it can modify it, but that would be inefficient. In simple examples, inlining the function would solve the problem, but in complex cases it maybe be most efficient to compile it down to something like:

fn example() {
  let mut x: u64 = 0
  x = increment(x)
}
fn increment(x: u64) -> u64 {
    return x + 1
}

so, mut primitive args would become return values, the args would be passed by value, and the value in the calling scope would be reassigned.

[alfsb]

mut primitive args simulated with invisible return values may work with stack allocated primitives, but would fail for heap allocated objects.

struct MutantTurtle {
    pub mut pizzas: u64
}

let t = new MutantTurtle { pizzas = 0 }
mut1( t , t.pizzas )

pub fn mut1( t: &MutantTurtle, mut pi: &u64 ) {
    pi = 1
    mut2( t , pi )
}

pub fn mut2( t: &MutantTurtle, mut zza: &u64 ) MutantTurtle {
    assert( t.pizzas == zza )                 // will fail
    return new MutantTurtle { pizzas = zza }; // copy
}