Re: project euler 26

[Ben Bacarisse <ben.usenet@bsb.me.uk>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:

> On 2023-09-05 17:18, Ben Bacarisse wrote:
>
>> There was
>> boiler plate code in my program that could be abstracted out into a
>> generic function (or package?) so that any function can be maximised
>> over some range or, better yet, any iterable type (if that's how Ada
>> does things).
>
>> Can someone here show me how?
>
> You define some classes. Either generic or tagged. E.g. a generic class of
> functions that uses two generic classes of the argument and the value:
>
> generic
>    -- Ordered argument
>    type Argument_Type is private;
>    with function Next (Value : Argument_Type)
>       return Argument_Type is <>;
>    with function "<" (Left, Right : Argument_Type)
>       return Boolean is <>;
>    with function "=" (Left, Right : Argument_Type)
>       return Boolean is <>;
>    -- Comparable value
>    type Value_Type is private;
>    with function "<" (Left, Right : Value_Type ) return Boolean is <>;
>    -- Function type
>    with function Func (Argument : Argument_Type) return Value_Type;
> function Generic_Maximum_At (Left, Right : Argument_Type)
>    return Value_Type;
>
> and the implementation
>
> function Generic_Maximum_At (Left, Right : Argument_Type)
>    return Value_Type is
>    Argument : Argument_Type := Left;
>    Max      : Value_Type;
>    Value    : Value_Type;
> begin
>    if Right < Left then
>       raise Constraint_Error with "Empty interval";
>    end if;
>    Max := Func (Argument);
>    while not (Argument = Right) loop
>       Argument := Next (Argument);
>       Value := Func (Argument);
>       if Max < Value then
>          Max := Value;
>       end if;
>    end loop;
>    return Max;
> end Generic_Maximum_At;
>
> or you can choose to pass the function as an argument:
>
> generic
>    -- Ordered argument
>    type Argument_Type is private;
>    with function Next (Value : Argument_Type)
>       return Argument_Type is <>;
>    with function "<" (Left, Right : Argument_Type)
>       return Boolean is <>;
>    -- Comparable value
>    type Value_Type is private;
>    with function "<" (Left, Right : Value_Type) return Boolean is <>;
> function Generic_Maximum_At
>          (  Left, Right : Argument_Type;
>             Func : access function (Argument : Argument_Type)
>                    return Value_Type
>          )  return Value_Type;
>
> Or you can make it a package which is usually a better choice as one can
> pack into it several entities sharing the same generic interface:
>
> generic
>    -- Ordered argument
>    type Argument_Type is private;
>    with function Next (Value : Argument_Type)
>       return Argument_Type is <>;
>    with function "<" (Left, Right : Argument_Type )
>       return Boolean is <>;
>    with function "=" (Left, Right : Argument_Type)
>       return Boolean is <>;
>    -- Comparable value
>    type Value_Type is private;
>    with function "<" (Left, Right : Value_Type) return Boolean is <>;
> package Generic_Discrete_Comparable_Valued is
>    function Maximum_At
>             (  Left, Right : Argument_Type;
>                Func : access function (Argument : Argument_Type)
>                       return Value_Type
>             )  return Value_Type;
>    -- Other useless functions
> end Generic_Discrete_Comparable_Valued;
>
> The generic classes of arguments/values can be in turn factored out into
> reusable generic packages:
>
> generic
>    -- Ordered argument
>    type Argument_Type is private;
>    with function Next (Value : Argument_Type) return Argument_Type is <>;
>    with function "<" (Left, Right : Argument_Type) return Boolean is <>;
>    with function "=" (Left, Right : Argument_Type) return Boolean is <>;
> package Generic_Arguments is
> end Generic_Arguments;
>
> generic
>    -- Comparable value
>    type Value_Type is private;
>    with function "<" (Left, Right : Value_Type ) return Boolean is <>;
> package Generic_Values is
> end Generic_Values;
>
> generic
>    with package Arguments is new Generic_Arguments (<>);
>    with package Values is new Generic_Values (<>);
> package Generic_Discrete_Comparable_Valued is
>    use Arguments, Values;
>    function Maximum_At
>             (  Left, Right : Argument_Type;
>                Func : access function (Argument : Argument_Type)
>                       return Value_Type
>             )  return Value_Type;
>    -- Other useless functions
> end Generic_Discrete_Comparable_Valued;

Thank you.  I can't yet see how to use any of these alternatives, but
that's my problem.  Are there any good online sources on Ada generic
programming so I can find out how to implement and use this short of
package?

-- 
Ben.