How do you specialize a generic function from a nested function?

How do you specialize a generic function from a nested function?

[EGarrulo]

I am trying to write a generic predicate that negates a supplied predicate.  The generic predicate compiles, but the compilation of client code fails with "generic subprogram cannot be called" (because the client code supplies a nested predicate, I suppose).  Here is the code (see the comment in the last file).

------------- negate.ads ------------------

generic
   type Value_Type is private;
   with function Predicate (Value : Value_Type) return Boolean;
   -- I have also tried with:
   -- Predicate : access function (Value : Value_Type) return Boolean;
function Negate (Value : Value_Type) return Boolean;

------------- negate.adb ------------------

function Negate (Value : Value_Type) return Boolean is
begin
   return not Predicate (Value);
end Negate;

------------- test.adb ------------------

with Negate;

procedure test is
   function Is_Zero (Value: Integer) return Boolean is (Value = 0);

   Is_Not_Zero : access function (Value: Integer) return Boolean 
   := Negate(Integer, Is_Zero'Access); -- <<== ##### ERROR HERE #####
begin
   null;
end test;

--------------------------------------


What is wrong?  And -- in any case -- could the code be simplified?  Thank you.

Re: How do you specialize a generic function from a nested function?

[Dmitry A. Kazakov]

On Sun, 26 Jul 2015 01:29:35 -0700 (PDT), EGarrulo wrote:

> ------------- negate.ads ------------------
> 
> generic
>    type Value_Type is private;
>    with function Predicate (Value : Value_Type) return Boolean;
>    -- I have also tried with:
>    -- Predicate : access function (Value : Value_Type) return Boolean;
> function Negate (Value : Value_Type) return Boolean;
> 
> ------------- negate.adb ------------------
> 
> function Negate (Value : Value_Type) return Boolean is
> begin
>    return not Predicate (Value);
> end Negate;
> 
> ------------- test.adb ------------------
> 
> with Negate;
> 
> procedure test is
>    function Is_Zero (Value: Integer) return Boolean is (Value = 0);
> 
>    Is_Not_Zero : access function (Value: Integer) return Boolean 
>    := Negate(Integer, Is_Zero'Access); -- <<== ##### ERROR HERE #####
> begin
>    null;
> end test;
> 
> --------------------------------------
> 
> 
> What is wrong?

You have to instantiate the generic:

   function Is_Not_Zero is new Negate (Integer, Is_Zero);

> And -- in any case -- could the code be simplified?

That depends on what are you going to achieve. Generics are never simple
and never handy. Avoid them if you can.

If you want to implement some algebra of functions use a tagged type to
represent a function (not an Ada's function, not an Ada's generic
function). Have a primitive operation Evaluate to execute the "function".
Implement operations on "functions" (like "get inverse function") as
operations of the type.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de