All the discussion about const on this NG lately has made me realize that I have no idea what the difference is between const and in, i.e. what is the difference between:

SomeType foo(const SomeType bar) and
SomeType foo(in SomeType bar)

?

dsimcha wrote:
> All the discussion about const on this NG lately has made me realize that I
> have no idea what the difference is between const and in, i.e. what is the
> difference between:
> 
> SomeType foo(const SomeType bar) and
> SomeType foo(in SomeType bar)

There's no difference between them.  The 'in' version just happens to be D1-compatible, and its meaning could be more easily changed over time if any tweaking is necessary (unlikely).

Sean Kelly wrote:

> dsimcha wrote:
>> All the discussion about const on this NG lately has made me realize that I have no idea what the difference is between const and in, i.e. what is the difference between:
>> 
>> SomeType foo(const SomeType bar) and
>> SomeType foo(in SomeType bar)
> 
> There's no difference between them.  The 'in' version just happens to be D1-compatible, and its meaning could be more easily changed over time if any tweaking is necessary (unlikely).
I have not done any D2, but surely 'in' is modifiable in the function locally
where as const is not (so since const is not modifiable at all it implies
in).
For example:

void myfunc(in int i)
{
	i = 10;	// i is changed to 10, k stays as 12
}

int k = 12;
myfunc(k);

=================================

void myfunc(const int i)
{
	i = 10;	// Fails to compile as i is const
}

in k = 12;
myfunc(k);

Sat, 7 Mar 2009 15:37:07 +0000 (UTC), dsimcha wrote:

> All the discussion about const on this NG lately has made me realize that I have no idea what the difference is between const and in, i.e. what is the difference between:
> 
> SomeType foo(const SomeType bar) and
> SomeType foo(in SomeType bar)
> 
> ?

In D1, there are no const types, so the first form doesn't compile.  In the second form 'in' is redundant,  it means the default behavior and may be omitted without consequences.

In D2, 'in' means 'const scope'.  I've seen that in writing but can't remember where.

Therefore clever people use 'in' to mean 'const' in D2 and NOP in D1 to improve portability.

Adam Burton wrote:
> Sean Kelly wrote:
> 
>> dsimcha wrote:
>>> All the discussion about const on this NG lately has made me realize that
>>> I have no idea what the difference is between const and in, i.e. what is
>>> the difference between:
>>>
>>> SomeType foo(const SomeType bar) and
>>> SomeType foo(in SomeType bar)
>> There's no difference between them.  The 'in' version just happens to be
>> D1-compatible, and its meaning could be more easily changed over time if
>> any tweaking is necessary (unlikely).
> I have not done any D2, but surely 'in' is modifiable in the function locally where as const is not (so since const is not modifiable at all it implies in).
> For example:
> 
> void myfunc(in int i)
> {
> 	i = 10;	// i is changed to 10, k stays as 12
> }
> 
> int k = 12;
> myfunc(k);	
> 
> =================================
> 
> void myfunc(const int i)
> {
> 	i = 10;	// Fails to compile as i is const
> }
> 
> in k = 12;
> myfunc(k);
> 

No it's not. "in" means "const scope" in D2 (and scope is a NOP right now).

Sat, 07 Mar 2009 17:43:19 -0800, Robert Fraser wrote:

> Adam Burton wrote:
>> Sean Kelly wrote:
>> 
>>> dsimcha wrote:
>>>> All the discussion about const on this NG lately has made me realize that I have no idea what the difference is between const and in, i.e. what is the difference between:
>>>>
>>>> SomeType foo(const SomeType bar) and
>>>> SomeType foo(in SomeType bar)
>>> There's no difference between them.  The 'in' version just happens to be D1-compatible, and its meaning could be more easily changed over time if any tweaking is necessary (unlikely).
>> I have not done any D2, but surely 'in' is modifiable in the function locally
>> where as const is not (so since const is not modifiable at all it implies
>> in).
>> For example:
>> 
>> void myfunc(in int i)
>> {
>> 	i = 10;	// i is changed to 10, k stays as 12
>> }
>> 
>> int k = 12;
>> myfunc(k);
>> 
>> =================================
>> 
>> void myfunc(const int i)
>> {
>> 	i = 10;	// Fails to compile as i is const
>> }
>> 
>> in k = 12;
>> myfunc(k);
>> 
> 
> No it's not. "in" means "const scope" in D2 (and scope is a NOP right now).

Closures are not allocated for delegates passed as scope arguments so scope is far from NOP.