On Thursday, 28 August 2025 at 11:54:10 UTC, Brother Bill wrote:
If line 9 of the program is commented out, it runs fine.
Otherwise lots of error messages which don't pan out for me.
I tried changing Negative.front to be const, which didn't help.
I am not quite sure what the error messages are telling me.

Thank you for your assistance!

```
C:\D\dmd2\windows\bin64\..\..\src\phobos\std\range\package.d(4560): Error: 
mutable method `app.Negative!(Take!(FibonacciSeries)).Negative.front` is not 
callable using a `const` object
                return _current.front;
                       ^
c:\dev\D\81 - 90\c82_1e_InputRange_does_support_cycle_with_save\source\app.d(44): Consider adding `const` or `inout` here
    auto front()
         ^
C:\D\dmd2\windows\bin64\..\..\src\phobos\std\range\package.d(4695): Error: 
template instance `std.range.Cycle!(Negative!(Take!(FibonacciSeries)))` error 
instantiating
    else return Cycle!R(input);
                ^
c:\dev\D\81 - 90\c82_1e_InputRange_does_support_cycle_with_save\source\app.d(9): instantiated from here: `cycle!(Negative!(Take!(FibonacciSeries)))`
            .cycle      // ← compilation ERROR
            ^
```

source/app.d
```
import std.stdio;
import std.range;

void main()
{
        writeln(FibonacciSeries()
                        .take(5)
                        .negative
                        .cycle      // ← compilation ERROR
                        .take(10));
}

struct FibonacciSeries
{
        int current = 0;
        int next = 1;
        enum empty = false;
        int front() const
        {
                return current;
        }

        void popFront()
        {
                const nextNext = current + next;
                current = next;
                next = nextNext;
        }

        FibonacciSeries save() const
        {
                return this;
        }
}

struct Negative(T) if (isInputRange!T)
{
        T range;
        bool empty()
        {
                return range.empty;
        }

        auto front()
        {
                return -range.front;
        }

        void popFront()
        {
                range.popFront();
        }

        static if (isForwardRange!T)
        {
                Negative save()
                {
                        return Negative(range.save);
                }
        }
}

Negative!T negative(T)(T range)
{
        return Negative!T(range);
}
```

add it to the pile of phoboes safetyism breaking code; also see, nullable is 1000 lines long, breaks naive type inference when a 5 line version often outcompetes it

cycle can be defined like this:
```d
void main()
{
        writeln(FibonacciSeries()
                        .take(5)
                        .negative
                        .mycycle      // ← compilation ERROR
                        .take(10));
}
auto mycycle(R)(R r){
    struct cycle{
        R r;
        R backup;
        auto front()=>r.front;
        void popFront(){
            r.popFront();
            if(r.empty){r=backup;}
        }
        enum empty=false;
    }
    return cycle(r,r);
}
```

phoboes cycle has a bunch of overloads a type infomation, so Id bet theres a confused "ElementType" inferring const (even if you dont add it it may be *incorrectly* inferred, safetism is just function coloring bullshit) in its dense web

for example: https://github.com/dlang/phobos/blob/205256abb1f86faf986f8c789cb733ca4137246e/std/range/package.d#L4621

```d
    @property ref inout(ElementType) front() inout @safe
    {
static ref auto trustedPtrIdx(typeof(_ptr) p, size_t idx) @trusted
        {
            return p[idx];
        }
        return trustedPtrIdx(_ptr, _index);
    }
```

they added an overload that handles "random access ranges" differently(so this isnt the only one of these); they added at least 4 safetism attributes, added a static function and 8 lines of code that only does `ref front()=>r.front;`

They lose the plot and you have to sometimes offer your own solutions, its often not worth debugging, if you see an ugly phoboes error on what should be a simple range concept, consider not even looking.

Reply via email to