Почему все так не любят Delphi

R1 find(alias pred = "a == b", R1, R2)(R1 haystack, R2 needle)
if (isRandomAccessRange!R1 && isForwardRange!R2 && !isBidirectionalRange!R2 &&
    is(typeof(binaryFun!pred(haystack.front, needle.front)) : bool))
{
    static if (!is(ElementType!R1 == ElementType!R2))
    {
        return simpleMindedFind!pred(haystack, needle);
    }
    else
    {
        // Prepare the search with needle's first element
        if (needle.empty)
            return haystack;
 
        haystack = .find!pred(haystack, needle.front);
 
        static if (hasLength!R1 && hasLength!R2 && is(typeof(takeNone(haystack)) == R1))
        {
            if (needle.length > haystack.length)
                return takeNone(haystack);
        }
        else
        {
            if (haystack.empty)
                return haystack;
        }
 
        needle.popFront();
        size_t matchLen = 1;
 
        // Loop invariant: haystack[0 .. matchLen] matches everything in
        // the initial needle that was popped out of needle.
        for (;;)
        {
            // Extend matchLength as much as possible
            for (;;)
            {
                import std.range : takeNone;
 
                if (needle.empty || haystack.empty)
                    return haystack;
 
                static if (hasLength!R1 && is(typeof(takeNone(haystack)) == R1))
                {
                    if (matchLen == haystack.length)
                        return takeNone(haystack);
                }
 
                if (!binaryFun!pred(haystack[matchLen], needle.front))
                    break;
 
                ++matchLen;
                needle.popFront();
            }
 
            auto bestMatch = haystack[0 .. matchLen];
            haystack.popFront();
            haystack = .find!pred(haystack, bestMatch);
        }
    }
}

import std.exception, std.stdio;
 
struct CustomInteger(T, T minValue, T maxValue)
{
    T value_;
    
    alias value this;
    
    @property T value() const
    {
        enforce((value_ >= minValue) &&
                (value_ <= maxValue));
        
        return value_;
    }
    
    @property void value(T v)
    {
        value_ = v;
    }
}
 
void main()
{
    alias Balance = CustomInteger!(int, -32_000, 32_000);
    
    auto b = Balance(42);
    
    // b += 5; // Error: 'b += 5' is not a scalar,
    // it is a CustomInteger!(int, -32000, 32000)
    
    writeln(b); // 42
 
    b = 40_000;
 
    writeln(b); // object.Exception@acm.d(11): Enforcement failed
}

import std.exception, std.stdio;
 
struct CustomInteger(T, T minValue, T maxValue)
{
    T value_;
    
    alias value this;
    
    @property T value() const
    {
        enforce((value_ >= minValue) &&
                (value_ <= maxValue));
        
        return value_;
    }
    
    @property void value(T v)
    {
        value_ = v;
    }
 
    ref CustomInteger opOpAssign(string op, T2)(T2 rhs)
    {
        static if (is (T2 == CustomInteger)) {
            mixin("value_ " ~ op ~ "= rhs.value_;");
            return this;
            
        } else {
            return opOpAssign!op(CustomInteger(rhs));
        }
    }
 
}
 
void main()
{
    alias Balance = CustomInteger!(int, -32_000, 32_000);
    
    auto b = Balance(42);
    
    b += 5; // OK
    
    writeln(b); // 47
}