Function templates fail since build 2190

Hello,

hope this is not a duplicate, but i've noticed, the documentation to mql5 concerning function templates is showing code, that does not compile any more, redering the template functionality more or less useless. (And broke my code)

The documentation shows an exmpel at https://www.mql5.com/en/docs/basis/oop/templates:

with the code comparing ( "opeartor <()" ) a templated datatype, which the compiler now errors out as illegal operation in use.

template<typename T>
T ArrayMax(T &arr[])
  {
   uint size=ArraySize(arr);
   if(size==0) return(0);          
   
   T max=arr[0];
   for(uint n=1;n<size;n++)
      if(max<arr[n]) max=arr[n];
//---
   return(max);
  }

if(max<arr[n]) // <- Fails to compile: '<' - illegal operation use

This concerns up to build 2204.

How to refactor the code to be able to compile this functionality again?

Help would be very appreciated.

Thank you.

Example code:

// Container class
class ea_dbl
{
    // Double storage
    public:
        double  m_dbl;


    // Object handlers
                void                    ea_dbl()                                                           { m_dbl = EMPTY_VALUE; }
                void                    ea_dbl(const double inVal)                                         { m_dbl = inVal; }
                void                    ea_dbl(const ea_dbl& inVal)                                        { m_dbl = inVal.m_dbl; }

    // Public interface
    public:

        // Virtual interface
        virtual double                  Get()                                                        const { return(GetRawDouble()); }


        // Default interface
        virtual double                  GetRawDouble()                                               const { return(m_dbl); }
        virtual double                  GetAbs()                                                     const { return(fabs(m_dbl)); }

        virtual bool                    GetEmpty()                                                   const { return(m_dbl == EMPTY_VALUE); }
        virtual void                    SetEmpty()                                                         { m_dbl = EMPTY_VALUE; }


    // Operators
    public:

    // Generic Operators: Operators: !, ++, --

        // ea_dbl selfreferencing operators
        virtual bool                    operator !  ()                                               const { return( (m_dbl == EMPTY_VALUE) || (m_dbl <= MathPow(10, ((Digits()+3) * -1))) ); }
        virtual void                    operator ++ ()                                                     { m_dbl += MathPow(10, (Digits() * -1)); }
        virtual void                    operator -- ()                                                     { m_dbl -= MathPow(10, (Digits() * -1)); }


    // Operators: +, -, *, /, %, =, +=, -=, *=, /=, %=

        // double as input
        virtual double                  operator +  (const double inVal)                             const { return(m_dbl + inVal); }
        virtual double                  operator -  (const double inVal)                             const { return(m_dbl - inVal); }
        virtual double                  operator *  (const double inVal)                             const { return(m_dbl * inVal); }
        virtual double                  operator /  (const double inVal)                             const { return(m_dbl / inVal); }

        virtual void                    operator =  (const double inVal)                                   { m_dbl =  inVal; }
        virtual void                    operator += (const double inVal)                                   { m_dbl += inVal; }
        virtual void                    operator -= (const double inVal)                                   { m_dbl -= inVal; }
        virtual void                    operator *= (const double inVal)                                   { m_dbl *= inVal; }
        virtual void                    operator /= (const double inVal)                                   { m_dbl /= inVal; }
};






template<typename T> T ArrayMax(T &arr[])
{
    uint size = ArraySize(arr);
    if(size == 0) return(NULL);          
    
    T max = arr[0];
    for(uint n = 1; n < size; n++)
    { if(max < arr[n]) max = arr[n]; }
    
    return(max);
}



int OnInit()
{
    ea_dbl test[];
    ArrayResize(test, 10);
    
    ea_dbl result = ArrayMax<ea_dbl>(test);
    

    return(INIT_SUCCEEDED);
}


//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{


    return;
}