On Sun, 11 Jan 2009 19:56:55 +1300, Denis Koroskin <2korden@gmail.com> wrote:

> On Sun, 11 Jan 2009 06:04:01 +0300, Tim M <a@b.com> wrote:
>
>> On Sun, 11 Jan 2009 15:59:26 +1300, Tim M <a@b.com> wrote:
>>
>>> On Sun, 11 Jan 2009 15:50:54 +1300, Daniel Keep <daniel.keep.lists@gmail.com> wrote:
>>>
>>>>
>>>>
>>>> Tim M wrote:
>>>>>  Why is this an error. Dmd wants to make sure that I declare a new variable in the foreach statement and not use an existing one?
>>>>>  module test;
>>>>>  void main()
>>>>> {
>>>>>     int i;
>>>>>     int[] nums;
>>>>>     foreach(i; nums)
>>>>>     {
>>>>>         //
>>>>>     }
>>>>> }
>>>>>   dmd test.d
>>>>>  test.d(7): Error: shadowing declaration test.main.i is deprecated
>>>>
>>>> Yes; as the error states, you're not allowed to define variables with the same name as variables in an enclosing scope any more.
>>>>
>>>>    -- Daniel
>>>
>>> Why does it still work for some objects?
>>
>>
>> This works:
>>
>>
>> module test;
>>
>> class A
>> {
>> 	this()
>> 	{
>> 		//
>> 	}
>> }
>>
>> class B
>> {
>> 	this()
>> 	{
>> 		//
>> 	}
>>   	int opApply (int delegate (inout B) dg)
>>          {
>>                  return 1;
>>          }
>> }
>>
>> void main()
>> {
>> 	A a;
>> 	B b;
>> 	foreach(a; b)
>> 	{
>> 		//
>> 	}
>> }
>>
>
> It is a bug and should be reported.
>


Yep that probibly is a slight bug. What I would like to know is why cant I do foreach with primitive types like I can with objects. The objects use an existing variable but an int would require a new int defined with the foreach params.

On Sun, 11 Jan 2009 10:08:47 +0300, Tim M <a@b.com> wrote:

> On Sun, 11 Jan 2009 19:56:55 +1300, Denis Koroskin <2korden@gmail.com> wrote:
>
>> On Sun, 11 Jan 2009 06:04:01 +0300, Tim M <a@b.com> wrote:
>>
>>> On Sun, 11 Jan 2009 15:59:26 +1300, Tim M <a@b.com> wrote:
>>>
>>>> On Sun, 11 Jan 2009 15:50:54 +1300, Daniel Keep <daniel.keep.lists@gmail.com> wrote:
>>>>
>>>>>
>>>>>
>>>>> Tim M wrote:
>>>>>>  Why is this an error. Dmd wants to make sure that I declare a new variable in the foreach statement and not use an existing one?
>>>>>>  module test;
>>>>>>  void main()
>>>>>> {
>>>>>>     int i;
>>>>>>     int[] nums;
>>>>>>     foreach(i; nums)
>>>>>>     {
>>>>>>         //
>>>>>>     }
>>>>>> }
>>>>>>   dmd test.d
>>>>>>  test.d(7): Error: shadowing declaration test.main.i is deprecated
>>>>>
>>>>> Yes; as the error states, you're not allowed to define variables with the same name as variables in an enclosing scope any more.
>>>>>
>>>>>    -- Daniel
>>>>
>>>> Why does it still work for some objects?
>>>
>>>
>>> This works:
>>>
>>>
>>> module test;
>>>
>>> class A
>>> {
>>> 	this()
>>> 	{
>>> 		//
>>> 	}
>>> }
>>>
>>> class B
>>> {
>>> 	this()
>>> 	{
>>> 		//
>>> 	}
>>>   	int opApply (int delegate (inout B) dg)
>>>          {
>>>                  return 1;
>>>          }
>>> }
>>>
>>> void main()
>>> {
>>> 	A a;
>>> 	B b;
>>> 	foreach(a; b)
>>> 	{
>>> 		//
>>> 	}
>>> }
>>>
>>
>> It is a bug and should be reported.
>>
>
>
> Yep that probibly is a slight bug. What I would like to know is why cant I do foreach with primitive types like I can with objects.

You can use foreach to iterate over arrays and tuples, if that's what you mean. Iterating over over primitive types makes little sense.

> The objects use an existing variable but an int would require a new int defined with the foreach params.

You got it wrong, foreach never use an existing variable. Try yourself:

void main()
{
   B b;
   foreach (a; b)
   {
   }
}

Variable shadowing is disallowed for this very reason - to avoid "what variable do I use here" type of confusion.

The code you provided is incorrect, but compiler currently accepts it (which is a bug). You should remove "A a;" from the main, it is never used anyway.

On Sun, 11 Jan 2009 20:31:51 +1300, Denis Koroskin <2korden@gmail.com> wrote:


>> Yep that probibly is a slight bug. What I would like to know is why cant I do foreach with primitive types like I can with objects.
>
> You can use foreach to iterate over arrays and tuples, if that's what you mean. Iterating over over primitive types makes little sense.


Just re reading my own question I think it is clear what I meant. I meant array of primitives so yes iterating over an array, but an array of primitives. Dmd handles foreach over SomeObject[] a lot more relaxed than int[].

On Sun, 11 Jan 2009 11:04:38 +0300, Tim M <a@b.com> wrote:

> On Sun, 11 Jan 2009 20:31:51 +1300, Denis Koroskin <2korden@gmail.com> wrote:
>
>
>>> Yep that probibly is a slight bug. What I would like to know is why cant I do foreach with primitive types like I can with objects.
>>
>> You can use foreach to iterate over arrays and tuples, if that's what you mean. Iterating over over primitive types makes little sense.
>
>
> Just re reading my own question I think it is clear what I meant. I meant array of primitives so yes iterating over an array, but an array of primitives. Dmd handles foreach over SomeObject[] a lot more relaxed than int[].
>
>

Example, please? I never noticed any difference.

On Sun, 11 Jan 2009 21:39:55 +1300, Denis Koroskin <2korden@gmail.com> wrote:

> On Sun, 11 Jan 2009 11:04:38 +0300, Tim M <a@b.com> wrote:
>
>> On Sun, 11 Jan 2009 20:31:51 +1300, Denis Koroskin <2korden@gmail.com> wrote:
>>
>>
>>>> Yep that probibly is a slight bug. What I would like to know is why cant I do foreach with primitive types like I can with objects.
>>>
>>> You can use foreach to iterate over arrays and tuples, if that's what you mean. Iterating over over primitive types makes little sense.
>>
>>
>> Just re reading my own question I think it is clear what I meant. I meant array of primitives so yes iterating over an array, but an array of primitives. Dmd handles foreach over SomeObject[] a lot more relaxed than int[].
>>
>>
>
> Example, please? I never noticed any difference.

Ok just did another test. Objects are handled the same way like you said. The "problem" is actually in the opApply where it can work just fine (runs ok not just compiles ok) using the exisiting variable.

"Denis Koroskin" wrote
> On Sun, 11 Jan 2009 06:04:01 +0300, Tim M <a@b.com> wrote:
>
>> On Sun, 11 Jan 2009 15:59:26 +1300, Tim M <a@b.com> wrote:
>>
>>> On Sun, 11 Jan 2009 15:50:54 +1300, Daniel Keep <daniel.keep.lists@gmail.com> wrote:
>>>
>>>>
>>>>
>>>> Tim M wrote:
>>>>>  Why is this an error. Dmd wants to make sure that I declare a new
>>>>> variable in the foreach statement and not use an existing one?
>>>>>  module test;
>>>>>  void main()
>>>>> {
>>>>>     int i;
>>>>>     int[] nums;
>>>>>     foreach(i; nums)
>>>>>     {
>>>>>         //
>>>>>     }
>>>>> }
>>>>>   dmd test.d
>>>>>  test.d(7): Error: shadowing declaration test.main.i is deprecated
>>>>
>>>> Yes; as the error states, you're not allowed to define variables with the same name as variables in an enclosing scope any more.
>>>>
>>>>    -- Daniel
>>>
>>> Why does it still work for some objects?
>>
>>
>> This works:
>>
>>
>> module test;
>>
>> class A
>> {
>> this()
>> {
>> //
>> }
>> }
>>
>> class B
>> {
>> this()
>> {
>> //
>> }
>>   int opApply (int delegate (inout B) dg)
>>          {
>>                  return 1;
>>          }
>> }
>>
>> void main()
>> {
>> A a;
>> B b;
>> foreach(a; b)
>> {
>> //
>> }
>> }
>>
>
> It is a bug and should be reported.

I'm not so sure.

Would you say this is a bug (it compiles)?

int foo()
{
   int i;
   int innerfoo(int i)
   {
       return i;
   }
   return innerfoo(2); // returns 2
}

because that's basically what a foreach does when using opApply: create an inner function and then pass a delegate pointing to that function to opApply.

I think the difference between the two is that the compiler handles foreach on an array in a special manner without using an inner function/delegate. This also fails to compile:

void main()
{
  A a;
  A[] b;
  foreach(a; b)
  {
     //
  }
}

On Tue, Jan 13, 2009 at 6:25 AM, Steven Schveighoffer <schveiguy@yahoo.com> wrote:

> because that's basically what a foreach does when using opApply: create an inner function and then pass a delegate pointing to that function to opApply.
>
> I think the difference between the two is that the compiler handles foreach on an array in a special manner without using an inner function/delegate.

That's an implementation detail and shouldn't effect the behavior visible to the user.

--bb