## digitalmars.D - Re: What is the difference between...

"Janice Caron" <caron serenityfirefly.com> writes:
```-----Original Message-----
From: digitalmars-d-bounces puremagic.com
[mailto:digitalmars-d-bounces puremagic.com] On Behalf Of Daniel919
Sent: 07 September 2007 12:39
To: digitalmars-d puremagic.com
Subject: Re: What is the difference between...

(2) void f(const(int) x)

It is? Why? Why doesn't it mean x is a const int?

So f(const(int)* x) means x is a pointer to const int, but f(const(int) x) does
not mean x is a const int? Now I'm very, very confused.

Why am I not getting this?
```
Sep 07 2007
Bruno Medeiros <brunodomedeiros+spam com.gmail> writes:
```Janice Caron wrote:
-----Original Message-----
From: digitalmars-d-bounces puremagic.com
[mailto:digitalmars-d-bounces puremagic.com] On Behalf Of Daniel919
Sent: 07 September 2007 12:39
To: digitalmars-d puremagic.com
Subject: Re: What is the difference between...

(2) void f(const(int) x)

It is? Why? Why doesn't it mean x is a const int?

So f(const(int)* x) means x is a pointer to const int, but f(const(int)
x) does not mean x is a const int? Now I'm very, very confused.

Why am I not getting this?

const(...) makes everything inside the parenthesis const. But there is
one exception: If that const is part of a declaration, then the
top-level value/type is not const. (the top-level value is the one that
changes with assignments) So:

const(int)* x;  // mutable pointer to const int
const(int)  x;  // mutable int;
const(int*) x;  // mutable pointer to const int
const(int**) x;  // mutable pointer to const pointer to const int;
const(int*)* x;  // mutable pointer to const pointer to const int;
const(int)** x;  // mutable pointer to mutable pointer to const int;

The only way to apply const to the toplevel value, is to use const as a
"storage class" (crappy name). So:

const int* x;  // const pointer to const int

client?

--
Bruno Medeiros - MSc in CS/E student
http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D
```
Sep 07 2007
Sean Kelly <sean f4.ca> writes:
```Bruno Medeiros wrote:
Janice Caron wrote:
-----Original Message-----
From: digitalmars-d-bounces puremagic.com
[mailto:digitalmars-d-bounces puremagic.com] On Behalf Of Daniel919
Sent: 07 September 2007 12:39
To: digitalmars-d puremagic.com
Subject: Re: What is the difference between...

(2) void f(const(int) x)

It is? Why? Why doesn't it mean x is a const int?

So f(const(int)* x) means x is a pointer to const int, but
f(const(int) x) does not mean x is a const int? Now I'm very, very
confused.

Why am I not getting this?

const(...) makes everything inside the parenthesis const. But there is
one exception: If that const is part of a declaration, then the
top-level value/type is not const. (the top-level value is the one that
changes with assignments) So:

const(int)* x;  // mutable pointer to const int
const(int)  x;  // mutable int;
const(int*) x;  // mutable pointer to const int
const(int**) x;  // mutable pointer to const pointer to const int;
const(int*)* x;  // mutable pointer to const pointer to const int;

Wouldn't this be "mutable pointer to mutable pointer to const int?"

Sean
```
Sep 07 2007
Bruno Medeiros <brunodomedeiros+spam com.gmail> writes:
```Sean Kelly wrote:
Bruno Medeiros wrote:
Janice Caron wrote:
-----Original Message-----
From: digitalmars-d-bounces puremagic.com
[mailto:digitalmars-d-bounces puremagic.com] On Behalf Of Daniel919
Sent: 07 September 2007 12:39
To: digitalmars-d puremagic.com
Subject: Re: What is the difference between...

(2) void f(const(int) x)

It is? Why? Why doesn't it mean x is a const int?

So f(const(int)* x) means x is a pointer to const int, but
f(const(int) x) does not mean x is a const int? Now I'm very, very
confused.

Why am I not getting this?

const(...) makes everything inside the parenthesis const. But there is
one exception: If that const is part of a declaration, then the
top-level value/type is not const. (the top-level value is the one
that changes with assignments) So:

const(int)* x;  // mutable pointer to const int
const(int)  x;  // mutable int;
const(int*) x;  // mutable pointer to const int
const(int**) x;  // mutable pointer to const pointer to const int;
const(int*)* x;  // mutable pointer to const pointer to const int;

Wouldn't this be "mutable pointer to mutable pointer to const int?"

Sean

The last one :
const(int*)* x;
?

Nope, it's like I said. It can be verified with this:

x = null;   // Ok
*x = null;  // Error
**x = null; // Error

If people were thinking that const(<X>) would *allways* only apply
immutability to the referenced value of <X> (if X is a reference), then
that's wrong. It only does that when const(<X>) is the top-level type.

(BTW, naturally, the same is true for invariant)

--
Bruno Medeiros - MSc in CS/E student
http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D
```
Sep 07 2007
Sean Kelly <sean f4.ca> writes:
```Bruno Medeiros wrote:
Sean Kelly wrote:
Bruno Medeiros wrote:
Janice Caron wrote:
-----Original Message-----
From: digitalmars-d-bounces puremagic.com
[mailto:digitalmars-d-bounces puremagic.com] On Behalf Of Daniel919
Sent: 07 September 2007 12:39
To: digitalmars-d puremagic.com
Subject: Re: What is the difference between...

(2) void f(const(int) x)

It is? Why? Why doesn't it mean x is a const int?

So f(const(int)* x) means x is a pointer to const int, but
f(const(int) x) does not mean x is a const int? Now I'm very, very
confused.

Why am I not getting this?

const(...) makes everything inside the parenthesis const. But there
is one exception: If that const is part of a declaration, then the
top-level value/type is not const. (the top-level value is the one
that changes with assignments) So:

const(int)* x;  // mutable pointer to const int
const(int)  x;  // mutable int;
const(int*) x;  // mutable pointer to const int
const(int**) x;  // mutable pointer to const pointer to const int;
const(int*)* x;  // mutable pointer to const pointer to const int;

Wouldn't this be "mutable pointer to mutable pointer to const int?"

Sean

The last one :
const(int*)* x;
?

Nope, it's like I said.

So the "top-level value/type" rule you mention above applies to the
entire type rather than just the bit in parenthesis?  Then there is
effectively no difference between "const(int**) x" and "const(int*)*"
correct?  So why are both syntaxes accepted?

Sean
```
Sep 07 2007
Bruno Medeiros <brunodomedeiros+spam com.gmail> writes:
```Sean Kelly wrote:
Bruno Medeiros wrote:
Sean Kelly wrote:
Bruno Medeiros wrote:
Janice Caron wrote:
-----Original Message-----
From: digitalmars-d-bounces puremagic.com
[mailto:digitalmars-d-bounces puremagic.com] On Behalf Of Daniel919
Sent: 07 September 2007 12:39
To: digitalmars-d puremagic.com
Subject: Re: What is the difference between...

(2) void f(const(int) x)

It is? Why? Why doesn't it mean x is a const int?

So f(const(int)* x) means x is a pointer to const int, but
f(const(int) x) does not mean x is a const int? Now I'm very, very
confused.

Why am I not getting this?

const(...) makes everything inside the parenthesis const. But there
is one exception: If that const is part of a declaration, then the
top-level value/type is not const. (the top-level value is the one
that changes with assignments) So:

const(int)* x;  // mutable pointer to const int
const(int)  x;  // mutable int;
const(int*) x;  // mutable pointer to const int
const(int**) x;  // mutable pointer to const pointer to const int;
const(int*)* x;  // mutable pointer to const pointer to const int;

Wouldn't this be "mutable pointer to mutable pointer to const int?"

Sean

The last one :
const(int*)* x;
?

Nope, it's like I said.

So the "top-level value/type" rule you mention above applies to the
entire type rather than just the bit in parenthesis?

Yes, if by "entire type" we mean the type of a declarations (and of
typeofs too).

Then there is
effectively no difference between "const(int**) x" and "const(int*)*"
correct?

Nope.

So why are both syntaxes accepted?

Sean

I would *guess* it's so you have a way to declare a mutable class
(reference) that refers to immutable class data. I.e.:
const(Foo) foo;
then 'foo = xpto' is allowed, but 'foo.x = xpto' is not.
If const(<X>) were to work without that exception rule, then there would
be no way to declare something like the above. For pointers you could do:
const(int)* x;
but for classes, there would be no syntax.

But one would have to ask Walter to know for sure.
Was any of this discussed at the conference? This 'head'/'tail' Robert
has been mentioned seems related. Seems the term 'head' is the same as
'top-level value'.

--
Bruno Medeiros - MSc in CS/E student
http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D
```
Sep 07 2007
Nathan Reed <nathaniel.reed gmail.com> writes:
```Bruno Medeiros wrote:
has been mentioned seems related. Seems the term 'head' is the same as
'top-level value'.

Yes.  The 'final' storage class makes the head const, which as you've
pointed out can't be done with the 'const' type constructor.  So:

const(int)* x;        // mutable pointer to const int
const(int*) x;        // mutable pointer to const int
final const(int)* x;  // const pointer to const int
final const(int*) x;  // const pointer to const int

(This is described on the lecture slides from the conference, so I'm not
sure if it is implemented quite this way yet.)

However, there is also still the 'const' storage class (as distinct from
the type constructor)...it's not clear to me exactly how that differs.

Does anyone else think this is much too confusing?  I realize D const is
a different animal from C++ const, but it seems to be badly in need of
some simplification.

Thanks,
Nathan Reed
```
Sep 07 2007
Sean Kelly <sean f4.ca> writes:
```Nathan Reed wrote:
Bruno Medeiros wrote:
This 'head'/'tail' Robert has been mentioned seems related. Seems the
term 'head' is the same as 'top-level value'.

Yes.  The 'final' storage class makes the head const, which as you've
pointed out can't be done with the 'const' type constructor.  So:

const(int)* x;        // mutable pointer to const int
const(int*) x;        // mutable pointer to const int
final const(int)* x;  // const pointer to const int
final const(int*) x;  // const pointer to const int

(This is described on the lecture slides from the conference, so I'm not
sure if it is implemented quite this way yet.)

However, there is also still the 'const' storage class (as distinct from
the type constructor)...it's not clear to me exactly how that differs.

The 'const' storage class is essentially the same as 'const' works in D
1.0 now.  The advantage being that the compiler can place the data in
ROM or simply use them as compile-time constants and not store them at all.

Does anyone else think this is much too confusing?  I realize D const is
a different animal from C++ const, but it seems to be badly in need of
some simplification.

I do.  In fact, as much as I hate to say it, I actually find the C++
declarative form easier to visually parse.  The new head/tail idea for D
2.0 is better than what we have now however, and I think we can do
better still (though I don't have any suggestions yet regarding how).

Sean
```
Sep 08 2007
Bruno Medeiros <brunodomedeiros+spam com.gmail> writes:
```Nathan Reed wrote:

Does anyone else think this is much too confusing?  I realize D const is
a different animal from C++ const, but it seems to be badly in need of
some simplification.

Thanks,
Nathan Reed

Yes, I also think it's very confusing, and it's not the only aspect of
the syntax I don't like, but what can we do...

--
Bruno Medeiros - MSc in CS/E student
http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D
```
Sep 08 2007