proposal: Go 2: a proposal to support final values and read-only parameters/results in Go

[zigo101]

(The latest version of this proposal is here.)

Please note, the following many comments are based on the initial proposal.

[zigo101]

I forget an important thing. The rules in the proposal don't apply to basic values. Or we need to introduce a new keyword fixed to replace the const keyword to support both basic and composite values.

[zigo101]

OK, it looks the fixed keyword is essential, I changed all const uses to fixed in the proposal.

[zigo101]

Updated the "assign immutable values to mutable values" part.

[zigo101]

Two use cases which become possible with this proposal:

	fixed bs = []byte(aString) // no underlying bytes are copied.
	
	fixed pb = &aString[0] // string bytes are addressable.

[zigo101]

I have an interesting idea to extend this proposal but will make this proposal more complex.

The fixed and fixed! can be unified as fixed:N, which N is a non-negative integer.
fixed! == fixed:0, fixed == fixed:1 and var == fixed:∞.

An example:

fixed:0 p = new(int)
pp := &p // <=> fixed:1 pp = &p <=> fixed pp = &p
ppp := &pp // <=> fixed:2 ppp = &pp
pppp := &ppp // <=> fixed:3 pppp = &ppp

// A value declared with fixed:N can only be dereferenced N times
// when its dereference is used as a destination value.

pp = new(**int) // ok
*pp = new(*int) // ok
**pp = new(int) // error: immutable

ppp = new(***int) // ok
*ppp = new(**int) // ok
**ppp = new(*int) // ok
***ppp = new(int) // error: immutable

pppp = new(****int) // ok
*pppp = new(***int) // ok
**pppp = new(**int) // ok
***pppp = new(*int) // ok
****pppp = new(int) // error: immutable


// a fixed:N value can be assigned to a fixed:M value if M <= N + 1.
// [update]: SORRY, the above old line is wrong. The following line is right.
// a fixed:N value can be assigned to a fixed:M value if M <= N.
fixed:2 pppp2 = pppp // ok
fixed:3 pppp3 = pppp // ok
fixed:4 pppp4 = pppp // error
fixed:5 pppp5 = pppp // error

[zigo101]

Ah! If we replace all the fixeds in my last comment with var, then we can save a keyword, and this propsoal can be Go 1 compatible!

[zigo101]

the comment previous to last is updated and corrected.

[zigo101]

The N in var:N means the mutable depth.

The following example shows some var:N uses:

type T *T
var t T
t = &t

var:0 x0 = t
x0 = t // error: "x0" is immutable.

var:1 x1 = t
x1 = t  // ok. "x1" is mutable.
*x1 = t // error: "*x1" is immutable.

var:2 x2 = t
x2 = t   // ok. "x2" is mutable
*x2 = t  // ok. "*x2" is mutable
**x2 = t // error: "**x2" is immutable.

var:3 x3 = t
x3 = t    // ok. "x3" is mutable
*x3 = t   // ok. "*x3" is mutable
**x3 = t  // ok. "**x3" is mutable
***x3 = t // error: "***x3" is immutable.

// var <=> var:∞
var x = t
x = t      // ok
*x = t     // ok
**x = t    // ok
***x = t   // ok
****x = t  // ok
*****x = t // ok
*******************************x = t