Fibonacci with ranges

[Jonathan M Davis]

On Saturday 12 March 2011 01:33:34 Russel Winder wrote:
> On Fri, 2011-03-11 at 18:46 -0500, Jesse Phillips wrote:
> > Without testing: foreach (f; take(recurrence!("a[n-1] + a[n-2]")(0UL,
> > 1UL), 50))
> > 
> > teo Wrote:
> > > Just curious: How can I get ulong here?
> > > 
> > > foreach (f; take(recurrence!("a[n-1] + a[n-2]")(0, 1), 50))
> > > {
> > > 
> > > 	writeln(f);
> > > 
> > > }
> 
> Interestingly, or not, the code:
> 
> long declarative ( immutable long n ) {
>   return take ( recurrence ! ( "a[n-1] + a[n-2]" ) ( 0L , 1L ) , n ) ;
> }
> 
> results in the return statement delivering:
> 
> rdmd --main -unittest fibonacci_d2.d
> fibonacci_d2.d(15): Error: template std.range.take(R) if
> (isInputRange!(Unqual!(R)) && !isSafelySlicable!(Unqual!(R)) &&
> !is(Unqual!(R) T == Take!(T))) does not match any function template
> declaration fibonacci_d2.d(15): Error: template std.range.take(R) if
> (isInputRange!(Unqual!(R)) && !isSafelySlicable!(Unqual!(R)) &&
> !is(Unqual!(R) T == Take!(T))) cannot deduce template function from
> argument types !()(Recurrence!(fun,long,2u),immutable(long))
> 
> which seems deeply impenetrable for mere mortals.

LOL. Maybe I've been dealing with template code for too long, because that seems 
perfectly clear to me. Though I can certainly understand why it wouldn't be. 
Incidentally, isSafelySlicable will be going away (essentially it's checking 
that the range isn't some type of char[] or wchar[], and Andrei's just going to 
make it so that isSliceable is false for them).

All that template constraint is checking for is that the range is an input range 
which can't be sliced and isn't already a range returned from take. If a range 
_is_ sliceable, then take just returns the same range type.

However, I don't think that constraint is necessarily all that useful in this 
case. It's just that it's the first version of the template, so that's the way 
that gets displayed when the compiler can't instantiate any of the versions of 
the template with the given arguments.

What's happening is that the parameter that you're passing n to for recurrence 
is size_t. And on 32-bit systems, size_t is uint, so passing n - which is long - 
to recurrence would be a narrowing conversion, which requires a cast. The 
correct thing to do would be make n a size_t. The other thing that you'd need to 
do is change declarative to return auto, since take returns a range, _not_ a 
long.

In any case, it _would_ be nice if the compiler gave a more informative message 
about _why_ the template failed to instantiate - especially since it's _not_ the 
template constraint which is the problem - but unfortunately, the compiler just 
isn't that smart about template instantiation errors.

- Jonathan M Davis