D const design rationale

Martin Howe martinhowe at myprivacy.ca
Sun Jun 24 02:46:49 PDT 2007


"Christopher Wright" <dhasenan at gmail.com> wrote in message 
news:f5kjll$92s$1 at digitalmars.com...
> Not at all. A final variable cannot be reassigned; the reference is const, 
> but the data is mutable.

Thanks - this has been confusing the heck out of me.  The problems seem to 
all stem from (a) coming from other languages and (c) overloading of 
keywords. The *concepts* are straightforward, it's knowing which keyword or 
combination of keywords means what.

A picture speaks a thousand words, so we REALLY REALLY REALLY need a TABLE 
here.

I have started one below  (you need a fixed-pitch font to view it, courier, 
courier new or fixedsys). I'd be very grateful if somebody (pref. Walter, 
since he likely knows more than anybody about all this) would 
correct/complete the table and repost it here.

LOCAL/GLOBAL VARIABLE
+---------------------------+-----------------------------------------+-----------------------------------------+
| KEYWORD(S)                |               VALUE TYPE                | 
REFERENCE TYPE             |
| 
+-------+------+-------+------------------+-------+------+-------+------------------+
|                           | CAN   | CAN   | CAN   | INVARIANCE      | CAN 
| CAN   | CAN   | INVARIANCE      |
|                           | MOD   | MOD   | MOD   | BEGINS          | MOD 
| MOD   | MOD   | BEGINS          |
|                           | DECL  | DATA  | DATA  |                 | DECL 
| DATA  | DATA  |                 |
|                           | REF   | VIA   | VIA   |                 | REF 
| VIA   | VIA   |                 |
|                           |       | DECLR | OTHER |                 | 
| DECLR | OTHER |                 |
|                           |       | REF   | REF   |                 | 
| REF   | REF   |                 |
+---------------------------+-------+-------+-------+-----------------+-------+-------+-------+-----------------+
| <none>                    | NO(1) | YES   | YES   | N/A             | YES 
| YES   | YES   | N/A             |
| invariant                 | NO(2) | NO    | NO(3) | AT COMPILE TIME | NO 
| NO    | NO(3) | COMPILE TIME(5) |
| const                     | NO(2) | NO    | NO(3) | AT COMPILE TIME | NO 
| NO    | NO(3) | COMPILE TIME(5) |
| const invariant (4)       | NO(2) | NO    | NO(3) | AT COMPILE TIME | NO 
| NO    | NO(3) | COMPILE TIME(5) |
| final                     | NO(2) | NO    | YES   | AT COMPILE TIME | NO 
| YES   | YES   | RUN TIME        |
| final const               | NO(2) | NO    | NO    | AT COMPILE TIME | NO 
| NO    | YES   | RUN TIME        |
| final invariant           | NO(2) | NO    | NO    | AT COMPILE TIME | NO 
| NO    | NO    | RUN TIME        |
| final const invariant (4) | NO(2) | NO    | NO    | AT COMPILE TIME | NO 
| NO    | NO    | RUN TIME        |
+---------------------------+-------+-------+-------+-----------------+-------+-------+-------+-----------------+

FUNCTION ARGUMENT
+---------------------------+-----------------------------------------+-----------------------------------------+
| KEYWORD(S)                |               VALUE TYPE                | 
REFERENCE TYPE             |
| 
+-------+------+-------+------------------+-------+------+-------+------------------+
|                           | CAN   | CAN   | CAN   | INVARIANCE      | CAN 
| CAN   | CAN   | INVARIANCE      |
|                           | MOD   | MOD   | MOD   | BEGINS          | MOD 
| MOD   | MOD   | BEGINS          |
|                           | DECL  | DATA  | DATA  |                 | DECL 
| DATA  | DATA  |                 |
|                           | REF   | VIA   | VIA   |                 | REF 
| VIA   | VIA   |                 |
|                           |       | DECLR | OTHER |                 | 
| DECLR | OTHER |                 |
|                           |       | REF   | REF   |                 | 
| REF   | REF   |                 |
+---------------------------+-------+-------+-------+-----------------+-------+-------+-------+-----------------+
| <none>                    | NO(1) | YES(6)| NO    | FUNC PROLOGUE   | 
|       |       |                 |
| invariant                 | NO(1) | NO    | NO(3) | FUNC PROLOGUE   | 
|       |       |                 |
| const                     | NO(1) | NO    | NO(3) | FUNC PROLOGUE   | 
|       |       |                 |
| const invariant (4)       | NO(1) | NO    | NO(3) | FUNC PROLOGUE   | 
|       |       |                 |
| final                     | NO(1) | NO    | YES(7)| FUNC PROLOGUE   | 
|       |       |                 |
| final const               | NO(1) | NO    | NO    | FUNC PROLOGUE   | 
|       |       |                 |
| final invariant           | NO(1) | NO    | NO    | FUNC PROLOGUE   | 
|       |       |                 |
| final const invariant (4) | NO(1) | NO    | NO    | FUNC PROLOGUE   | 
|       |       |                 |
+---------------------------+-------+-------+-------+-----------------+-------+-------+-------+-----------------+

(1) - NOT VISIBLE TO PROGRAMMER; EXISTS IN 
SYMBOL-TABLE/STACK/LOAD-FROM-MEMORY-INSTRUCTIONS ONLY

(2) - NOT VISIBLE TO PROGRAMMER; EXISTS IN 
SYMBOL-TABLE/LOAD-FROM-MEMORY-INSTRUCTIONS ONLY
      AND MAY EVEN HAVE BEEN REPLACED BY IMMEDIATE LOAD, DEPENDING ON 
IMPLEMENTATION AND TYPE.

(3) - CREATING OTHER REFERENCES IS NOT ALLOWED

(4) - SHOULD THIS BE LEGAL FOR VALUE TYPES? CERTAINLY REDUNDANT FOR THEM...

(5) - IMPOSSIBLE FOR REFERENCE TYPES THAT NEED CONSTRUCTORS/DESTRUCTORS; USE 
"FINAL INVARIANT" INSTEAD

(6) - USE OF A BY-VALUE ARGUMENT AS A LOCAL VARIABLE (ARGUABLY A "BAD THING 
[TM]")

(7) - POSSIBLE WITHIN THE FUNCTION, BUT WHY WOULD YOU WANT TO, ITS ONLY A 
**COPY OF** THE ORIGINAL ARGUMENT!! 





More information about the Digitalmars-d mailing list