Greetings all. First time poster here.
By way of introduction, my name is Christopher. I've been fascinated
with D for a few years now. My main programming language has been
Python, but I have used and studied many programming languages to some
extent. I love to design things, like houses, pipe organs, and even
computer languages.
What I like about D is that it seems to strike the right balance of
allowing fairly high level programming with static typing yet still
permitting access on several progressively deeper levels to the nuts and
bolts of the computer. I also love D's module system and its dynamic
arrays, to name just a few things.
Now down to business. I want to talk about const and immutable. There
are 5,256 posts in this list containing the text "const" so I just this
topic is discussed often.
We all know that object references are really implemented as pointers to
the object's data structures on the heap.
When we say "const Object a", we declare a constant variable pointing to
a constant data structure. Sometimes we need to declare a modifiable
variable pointing to a constant data structure.
I propose the syntax "objconst Object a" to declare modifiable reference
variable pointing to a const object data structure, and "objimmutable
Object A" for modifiable reference variable pointing to immutable object
data structure:
objimmutable Object a = cast(immutable) new Object();
objconst Object b = new Object();
b = a; // b is modifiable
// ILLEGAL: b references constant data structure
b.someVariable = newValue;
These could also be used in the parenthesized way:
objconst(Object) a;
objconst(Object)*[1] a_array;
a = new Object();
a_array[0] = &a;
*a_array[0] = new Object(); // change a to a different object
Now I understand that another syntax has been nominated to do this job
which is the const(Object)ref syntax. I dislike that syntax because
"const(Object)" means a constant variable referencing a constant data
structure, and "const(Object)ref" LOOKS like it should be a reference to
a variable of type "const(Object)" -- to me it suggests a variable
referencing a constant variable referencing a constant data structure.
"const(Object)ref" suggests TWO levels of pointers, but that is not the
meaning being ascribed thereunto.
I picked the keywords "objconst" and "objimmutable" to suggest that the
object data structure (hence the "obj" prefix) is immutable or const.
This was a compromise between brevity and descriptiveness. I suppose
they could also go "constobj" and "immutableobj".
Another reason why the objconst/objimmutable syntax is better than
"const(Object)ref" is that it requires fewer tokens to parse and to type
-- this makes it easier to read:
const(Object) ref a; // 5 tokens in the type
objconst Object a; // only 2 tokens
I submitted this idea to the bug tracking system as a feature request,
but I also want to hear what people have to say about it on here.
What do you think guys, Mr. Bright? And what do you like
better--"objconst" and "objimmutable" or "constobj" and "immutableobj"?
--Christopher
