What is the motivation for DIP1000 also applying to immutable?
For instance, in the code (compiled with -dip1000), adapted from
the spec [1], you get the same errors with immutable function
parameters as you would with mutable ones. However, should it
ever matter if you escape an immutable?
```d
@safe:
void thorin(scope immutable(int)*) {}
void gloin(immutable(int)*) {}
immutable(int)* balin(scope immutable(int)* q)
{
thorin(q);
gloin(q); // error, gloin() escapes q
return q; // error, cannot return 'scope' q
}
void main() {
immutable(int) x = 2;
immutable(int)* ptrx = &x;
immutable(int)* ptrz = balin(ptrx);
}
```
I tried basically the same thing in Rust and it doesn't generate
errors (their borrow checker should be assuming scope by default).
```rust
#![allow(unused_variables)]
fn gloin(x: &i32) {
}
fn ballin(x: &i32) -> &i32 {
gloin(x);
return x;
}
fn main() {
let x = 2;
let ptrx = &x;
let ptrz = ballin(ptrx);
}
```
[1] https://dlang.org/spec/function.html#scope-parameters
