Creating InputRanges from strings, files etc.

[Steven Schveighoffer]

On 11/8/18 11:15 AM, Vinay Sajip wrote:
> On Thursday, 8 November 2018 at 14:38:37 UTC, Paul Backus wrote:
>> To pass these ranges around using the `InputRange` interface, use 
>> `inputRangeObject` to wrap them:
>>
>>     InputRange!ubyte r3 = inputRangeObject(r1);
>>     InputRange!(immutable(ubyte)) r4 = inputRangeObject(r2);
> 
> I did a bit more digging, and it seems to work for strings but not for 
> files: The program
> 
> import std.algorithm.iteration;
> import std.format;
> import std.range;
> import std.stdio;
> import std.string;
> 
> void somefn(InputRange!(immutable(ubyte)) r) {
>      writeln(format!"%s"(r));
> }
> 
> void main()
> {
>      auto a = "Hello, world!";
>      auto b = inputRangeObject(a.representation);
>      somefn(b);
>      auto c = stdin.byChunk(1024).joiner;
>      auto d = inputRangeObject(c);
>      //somefn(d);
> }
> 
> compiles as given above, but if the somefn(d) line is uncommented, I get 
> an error:
> 
> function onlineapp.somefn(InputRange!(immutable(ubyte)) r) is not 
> callable using argument types (InputRangeObject!(Result))
> onlineapp.d(18):        cannot pass argument d of type 
> std.range.interfaces.InputRangeObject!(Result) to parameter 
> InputRange!(immutable(ubyte)) r
> 
> Do I need to do an explicit cast? If so, can someone tell me the precise 
> incantation? How come it doesn't figure out that the underlying range is 
> a ubyte range, or is it to do with immutability, or something else 
> altogether?

A cool feature of D is to have it tell you something about your code at 
compile time.

I did this in a run.dlang.org playground:

pragma(msg, ElementType!(typeof(b)));
pragma(msg, ElementType!(typeof(d)));

I get:
immutable(ubyte)
ubyte

Which means they aren't the same type, and they don't define the same 
interface (InputRange!(ubyte) is not the same as 
InputRange!(immutable(ubyte)) ).

Other than simply using compile-time functions, and dropping the object 
interface as Alex suggests, the easiest thing I can recommend is 
wrapping representation into a casting input range such as map:

auto b = inputRangeObject(a.representation.map!(b => ubyte(b)));

You can see all this here:

https://run.dlang.io/is/1E6Uqj

-Steve