Recent changes to keywords-const

keywords-const modified by Will Pittenger

Will Pittenger — Tue, 18 Feb 2014 10:01:57 -0000

--- v3
+++ v4
@@ -10,6 +10,8 @@
 Modifying class declarations
 ============================
 When you declare a class as constant, all non-static data members become both **const** and **[readonly](keywords-readonly)**.  All non-static methods become **const** and non-static properties are limited to **[get](keywords-accessors)**.  **const** can't be combined with **[static](keywords-static)** when used as a class modifier.  **const** goes before the **[class](keywords-class)** keyword.  **const** classes are effectively immutable.
+
+All operators are already **const** and can be used with any type declared **const**.

 ~~~~
 :::text
@@ -73,3 +75,7 @@
 ~~~~

 If this is a prototype for an **[interface](keywords-interface)**, **[abstract](keywords-abstract)** **[class](keywords-class)**, or for use as a **[delegate](keywords-delegate)** type; **[instructions](keywords-instructions)** must be followed by a list of types that will correspond to the variables made visible by the complex statement.  Otherwise, **[instructions](keywords-instructions)** must be followed by the actual variables.
+
+Operators
+---------
+All operators are already **const** and don't require use of the **const** keyword.

keywords-const modified by Will Pittenger

Will Pittenger — Tue, 18 Feb 2014 10:00:03 -0000

--- v2
+++ v3
@@ -8,7 +8,7 @@
 * To declare that a method won't change the any data members or call anything that could change a data member.

 Modifying class declarations
-----------------------------
+============================
 When you declare a class as constant, all non-static data members become both **const** and **[readonly](keywords-readonly)**.  All non-static methods become **const** and non-static properties are limited to **[get](keywords-accessors)**.  **const** can't be combined with **[static](keywords-static)** when used as a class modifier.  **const** goes before the **[class](keywords-class)** keyword.  **const** classes are effectively immutable.

 ~~~~
@@ -18,12 +18,58 @@
 ~~~~

 Declaring a run-time constant
------------------------------
-These are similar to **[conditional](keywords-conditional)** variables, except these are associated with a class and can't be used inside **[conditionalif](keywords-conditionalif)** statements.  Variables declared this way are both **const** (as described below and) **[readonly](keyword-readonly)**.
+=============================
+These are similar to **[conditional](keywords-conditional)** variables, except these are associated with a class and can't be used inside **[conditionalif](keywords-conditionalif)** statements.  Variables declared this way are both **const** (as described below and) **[readonly](keyword-readonly)**.  These variables are automatically **[static](keywords-static)** and not part of any one instance of the enclosing type.

 ~~~~
 :::text
-\const\ /TypeName/ /Identifier/ \=\ /Value/
+\const\ /TypeDescriptor/ /Identifier/ \=\ /Value/
 ~~~~

-/TypeName/ must be a type descriptor as described in [Type descriptors](Appendices-Terms-Type descriptors).  /Value/ must be an [R-Value](Appendices-Terms-r-value).
+/TypeDescriptor/ must be a type descriptor as described in [Type descriptors](Appendices-Terms-Type descriptors).  /Value/ must be an [R-Value](Appendices-Terms-r-value).
+
+Declaring a constant variable that isn't readonly
+=================================================
+If you combine **const** with **[var](keywords-var)** (in either order), you get a constant variable that doesn't have **[readonly](keywords-readonly)** applied to it.  Such variables can be initialized either when declared or by the **[constructor](keywords-constructor)**.  They can be **[static](keywords-static)** or non-**[static](keywords-static)**.  Regardless of how they are declared, they must be initialized by the time the **[constructor](keywords-constructor)** returns.  Otherwise, the compiler must issue an error.
+
+~~~~
+:::text
+(\var\ \const\ | \const\ \var\) /identifier/ [= /DefaultValue/]
+~~~~
+
+Declaring a constant method
+===========================
+If you place **const** between the access qualifier and the command/function/statement keywords, you're declaring a procedure that doesn't change any non-static data members or call anything that could change a non-static data member.  The compiler is required to enforce this rule.  **const** methods can be **[static](keywords-static)**, **[virtual](keywords-virtual)**, or **[abstract](keywords-abstract) as needed.
+
+In each case, /DeclarationSequence/ must be as described in [Declaration sequence](Appendices-Terms-Declaration sequence).  /TypeDescriptor/ must be as described in [Type descriptors](Appendices-Terms-Type descriptors).
+
+Commands
+--------
+~~~~
+:::text
+(\public\ | \protected\ | \private\) [\const\] [\static\] | [(\virtual\ | \abstract\)] \command\ [/DeclarationSequence/]
+    [\throws\ /TypeDescriptor/]
+  ' Run some code here
+~~~~
+
+Functions
+---------
+~~~~
+:::text
+(\public\ | \protected\ | \private\) [\const\] [\static\] | [(\virtual\ | \abstract\)] \command\ [/DeclarationSequence/]
+    (\returns\ /TypeDescriptor/ |
+    [\throws\ TypeDescriptor])
+  ' Run some code here
+~~~~
+
+Complex statements
+------------------
+~~~~
+:::text
+(\public\ | \protected\ | \private\) [\const\] [\static\] | [(\virtual\ | \abstract\)] \statement\ [/DeclarationSequence/]
+    [\throws\ /TypeDescriptor/]
+  ' Run some code here
+  \instructions\ ' See notes below
+~~~~
+
+If this is a prototype for an **[interface](keywords-interface)**, **[abstract](keywords-abstract)** **[class](keywords-class)**, or for use as a **[delegate](keywords-delegate)** type; **[instructions](keywords-instructions)** must be followed by a list of types that will correspond to the variables made visible by the complex statement.  Otherwise, **[instructions](keywords-instructions)** must be followed by the actual variables.

keywords-const modified by Will Pittenger

Will Pittenger — Tue, 18 Feb 2014 09:35:35 -0000

keywords-const modified by Will Pittenger

Will Pittenger — Tue, 18 Feb 2014 09:35:17 -0000

Modifying class declarations
Declaring a run-time constant

The const keyword can be used in several different ways.

As a class modifier
To declare a run-time constant
To declare that what a reference points to can't be changed
To declare that a method won't change the any data members or call anything that could change a data member.

Modifying class declarations

When you declare a class as constant, all non-static data members become both const and readonly. All non-static methods become const and non-static properties are limited to get. const can't be combined with static when used as a class modifier. const goes before the class keyword. const classes are effectively immutable.

[(\static\ | \const\)] \class\ /identifier/
  ' Declare nested-types, nested type-less named structures, data members, constructors, static constructors, creators, static creators, destructors, methods, and properties as needed

Declaring a run-time constant

These are similar to conditional variables, except these are associated with a class and can't be used inside conditionalif statements. Variables declared this way are both const (as described below and) readonly.

\const\ /TypeName/ /Identifier/ \=\ /Value/

/TypeName/ must be a type descriptor as described in Type descriptors. /Value/ must be an R-Value.