Yes, overloading functions in general is nice, like it is implemented in FPC, when you can have function with the same name but different formal parameters. Like:
function max(X,Y:real):real;
function max(X,Y:integer):integer;
function max(array of real):real;
But here you always know what happens. In contrast, when you have function which can treat your parameters sometimes as a variable, and sometimes as a constant, you do not immediately see what happens in this particular case. And this becomes even more tricky when you call the function from another function, like:
function Inner(rel A:integer):integer;
begin
....
end;
function Outer(rel A:integer):integer;
begin
Result := inner(A);
end;
It may be note easy to backtrack what is A and will it be treated as a variable or constant.
Everything has its price, and implementing more polymorphic and implicit behavior, we loose clarity and make language more prone to errors.
Well, yes, I am almost as conservative as N. Wirth himself