This proposal introduces constant function argument references, which allows for better enforcement of explicit variable mutability.

Stage: 0
Champion: tbd

For more information see the TC39 proposal process.

• Jeremiah Senkpiel (@fishrock123)

When declaring a function or an arrow function, adding const before an argument declaration makes the argument reference immutable, in the same manner as if the argument was a variable declared by the const variable declaration keyword. Just like const variables, the immutability is only by reference for objects, and does not extend deeply.

function (const a) {
  const b

  // a is immutable in the same way b is
}

(const a) => {
  const b

  // a is immutable in the same way b is
}

Default arguments still function as normal. The immutability happens once the function body begins, and default argument statements are treated as the declaration assignment.

function (const a = 'hello') {
  const b

  // a is immutable in the same way b is
  // if `a` was not passed to the function, `a` will be 'hello'
}

Additionally, the following example:

function outer (
    const a = 'hello',
    inner = (function inner (a = 'world') {
      console.log('inner', a)
    })()
  ) {
  console.log('outer', a)
}
outer()

Acts in the same way as:

function outer () {
  const a = 'hello'
  function inner (a) {
    a = 'world'
    console.log('inner', a)
  }
  inner()
  console.log('outer', a)
}
outer()

Constant function argument make the direct argument references immutable. This does not impact the arguments object, in strict or sloppy mode, which hold its own references and may be mutated as normal.

In sloppy mode, assigning to the arguments object will not update a constant function argument.

fn(1)

function fn (const a) {
  // a is 1

  arguments[0] = 2
  // a is 1
  // arguments[0] is 2
}

This proposal only touches what is currently missing. Neither let or var are necessary as that is already the default behavior.

The proposal has no impact on lexical or function scoping. As arguments are always declared before the function body, the lexical scope is always the function body.

Would it be possible to use const function arguments in an arrow function that has just one argument and no parentheses?

const myFunc = const a => {
  const b

  // a is immutable in the same way b is
}

Is a short-hand version desirable? What could be used that is still clear on its purpose?

TODO

TODO?

The following is a high-level list of tasks to progress through each stage of the TC39 proposal process:

• Identified a "champion" who will advance the addition.
• Prose outlining the problem or need and the general shape of a solution.
• Illustrative examples of usage.
• High-level API (proposal does not introduce an API).

• Initial specification text.
• Optional. Transpiler support.

• Complete specification text.
• Designated reviewers have signed off on the current spec text.
• The ECMAScript editor has signed off on the current spec text.

• Test262 acceptance tests have been written for mainline usage scenarios and merged.
• Two compatible implementations which pass the acceptance tests: [1], [2].
• A pull request has been sent to tc39/ecma262 with the integrated spec text.
• The ECMAScript editor has signed off on the pull request.

Proposal formatting taken from rbuckton's proposal-shorthand-improvements.