What should be signature of `foo` in the following piece of code?

    auto foo(range r) {
      // do something with the `r`
    }

    void main() {
      foo([1,2,3].map!(x => x*x));
    }


Right now I use `.array` to convert the range before passing:

    auto foo(int[] r) {
      // do something with the `r`
    }

    void main() {
      foo([1,2,3].map!(x => x*x).array);
    }

But it doesn't feel right.

Thanks,
-- 
Bahman

On Tuesday, 12 July 2016 at 03:57:09 UTC, Bahman Movaqar wrote:
> What should be signature of `foo` in the following piece of code?
>
>     auto foo(range r) {
>       // do something with the `r`
>     }
>
>     void main() {
>       foo([1,2,3].map!(x => x*x));
>     }
>
>

auto foo(R)(R r) { ... }

On 07/12/2016 11:07 AM, Mike Parker wrote:
> auto foo(R)(R r) { ... }

That did it.  Thanks.
Out of curiosity, does the same pattern apply to functions which take
`tuple`s as input arguments?

-- 
Bahman

On Tuesday, 12 July 2016 at 07:50:34 UTC, Bahman Movaqar wrote:
> On 07/12/2016 11:07 AM, Mike Parker wrote:
>> auto foo(R)(R r) { ... }
>
> That did it.  Thanks.
> Out of curiosity, does the same pattern apply to functions which take
> `tuple`s as input arguments?

It's just a function template. It's what you use whenever you need to deal with generic types.

https://dlang.org/spec/template.html

On Tue, Jul 12, 2016 at 06:37:35AM +0000, Mike Parker via Digitalmars-d-learn wrote:
> On Tuesday, 12 July 2016 at 03:57:09 UTC, Bahman Movaqar wrote:
> > What should be signature of `foo` in the following piece of code?
> > 
> >     auto foo(range r) {
> >       // do something with the `r`
> >     }
> > 
> >     void main() {
> >       foo([1,2,3].map!(x => x*x));
> >     }
> > 
> > 
> 
> auto foo(R)(R r) { ... }

Better yet:

	import std.range.primitives;
	auto foo(R)(R r) if (isInputRange!R) { ... }

This is to ensure R is actually a range, so that, for example, foo(123) will be rejected at compile-time.


T

-- 
"A man's wife has more power over him than the state has." -- Ralph Emerson