On Fri, Jan 20, 2023 at 03:11:33AM +0000, Ruby The Roobster via Digitalmars-d-learn wrote:
> Take this example:
> 
> ```d
> import std;
> void main()
> {
>     auto c = "a|b|c|d|e".splitter('|');
>     c.writeln;
>     string[] e = ["a", "b", "c", "d", "e"];
>     assert(c.equal(e));
>     typeof(c).stringof.writeln;
> }
> ```
> 
> The program prints:
> 
> ["a", "b", "c", "d", "e"]
> Result
> 
> What is the purpose of this 'Result' type?  To serve as a generic range?

It's a Voldemort type, representing a range that iterates over its elements lazily.


> Because, it seems to only cause problems.  For example, you cannot assign or cast the result type into a range, even when the type has the same inherent function:
> 
> ```d
> string[] c = "a|b|c|d|e".splitter('|'); // fails
> string[] d = cast(string[])"a|b|c|d|e".splitter('|'); // also fails
> ```

You're confusing arrays and ranges.  A "range" isn't any specific type, it refers to *any* type that behaves a certain way (behaves like a range).  Each `Result` you get back has its own unique type (arguably, it's a compiler bug to display it as merely `Result` without distinguishing it from other identically-named but distinct Voldemort types), so you cannot just assign it back to an array.

You can either create an array from it using std.array.array, use a function that eagerly creates its results instead of a lazy result (in the above instance, use std.string.split instead of .splitter), or use std.algorithm.copy to copy the contents of the lazy range into an array:

	// Option 1
	string[] c = "a|b|c|d|e".splitter('|').dup;

	// Option 2
	string[] c = "a|b|c|d|e".split('|');

	// Option 3
	// Caveat: .copy expects you to have prepared the buffer
	// beforehand to be large enough to hold the contents; it does
	// not reallocate the result array for you.
	string[] result = new string[5];
	"a|b|c|d|e".splitter('|').copy(result);


[...]
> Then what is the point of this type, if not to just make things difficult?  It cannot be casted, and vector operations cannot be performed, and it seems to just serve as an unnecessary generalization.

It serves to chain further range operations into a pipeline:

	string[] c = "a|b|c|d|e".splitter('|')
			.filter!(c => c >= 'b' && c <= 'd')
			.map!(c => c+1)
			.array;

Because ranges are lazily iterated, the .array line only allocates the 3 elements that got through the .filter. Whereas if you created the intermediate result array eagerly, you'd have to allocate space for 5 elements only to discard 2 of them afterwards.

One way to think about this is that the intermediate Result ranges are like the middle part of a long pipe; you cannot get stuff from the middle of the pipe without breaking it, you need to terminate the pipe with a sink (like .array, .copy, etc.) first.


T

-- 
I am Pentium of Borg. Division is futile; you will be approximated.

On Fri, Jan 20, 2023 at 03:34:43AM +0000, Ruby The Roobster via Digitalmars-d-learn wrote:
> On Friday, 20 January 2023 at 03:30:56 UTC, Steven Schveighoffer wrote:
> > On 1/19/23 10:11 PM, Ruby The Roobster wrote:
> > ...
> > 
> > The point is to be a range over the original input, evaluated lazily. Using this building block, you can create an array, or use some other algorithm, or whatever you want. All without allocating more space to hold an array.
[...]
> I get the point that it is supposed to be lazy.  But why are these basic cases not implemented?  I shouldn't have to go write a wrapper for something as simple as casting this type to the original type. This is one of the things that one expects the standard library to do for you.

There's no need to write any wrappers.  Just tack `.array` to the end of your pipeline, and you're good to go.


T

-- 
My father told me I wasn't at all afraid of hard work. I could lie down right next to it and go to sleep. -- Walter Bright

On 1/19/23 19:11, Ruby The Roobster wrote:

>      typeof(c).stringof.writeln;

> The program prints:
>
> ["a", "b", "c", "d", "e"]
> Result
>
> What is the purpose of this 'Result' type?

Just to make sure, 'Result' is what the programmer of a Phobos algorithm chose to name a struct type. It could be anything.

I will try to demonstrate it by naming my struct 'MyResult' below. The following range algorithm alternates between the two values it is called with.

The pragma(msg) inside 'main' prints MyResult.

auto alternate(T)(T a, T b) {
    // This function will return an object
    // of the following nested struct.
    // (Note: This is for demonsration
    // purposes only. Yes, this can be
    // be more optimal.)
    struct MyResult {
        bool useB = false;

        enum empty = false; // Infinite

        T front() {
            return useB ? b : a;
        }

        void popFront() {
            // Flip the selector
            useB = !useB;
        }
    }

    // Here, an object of the struct is
    // returned. It has single member (useB)
    // that it uses as a selector.
    // The values 'a' and 'b' are the actual
    // function arguments.
    return MyResult();
}

import std;

void main() {
    auto myRange = alternate(42, 7);

    // This prints 'MyResult' at compile time
    pragma(msg, typeof(myRange));

    const expected = [ 42, 7, 42, 7, 42 ];
    assert(myRange.take(5).equal(expected));
}

> even when the type
> has the same inherent function:

Different instantiations of templates are distinct types. For example, if I called 'alternate' with two 'long' values, both alternate!int (as instantiated by the code above) and alternate!long would have different MyResult struct types.

Although they would have the same functionality, they would be compiled potentially with very different CPU instructions and would not be assignable.

Ali