• dsimcha <dsimcha yahoo.com> Mar 07 2009
• Sean Kelly <sean invisibleduck.org> Mar 07 2009
• Adam Burton <adz21c googlemail.com> Mar 07 2009
• Robert Fraser <fraserofthenight gmail.com> Mar 07 2009
• Sergey Gromov <snake.scaly gmail.com> Mar 08 2009
• Sergey Gromov <snake.scaly gmail.com> Mar 07 2009

dsimcha <dsimcha yahoo.com> writes:

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)

?

Sean Kelly <sean invisibleduck.org> writes:

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).

Adam Burton <adz21c googlemail.com> writes:

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).


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);

Robert Fraser <fraserofthenight gmail.com> writes:

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)


 D1-compatible, and its meaning could be more easily changed over time if
 any tweaking is necessary (unlikely).


 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).

Sergey Gromov <snake.scaly gmail.com> writes:

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)


 D1-compatible, and its meaning could be more easily changed over time if
 any tweaking is necessary (unlikely).


 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.

Sergey Gromov <snake.scaly gmail.com> writes:

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.