Re: class wide iterable (and indexable)

[Jere <jhb.chat@gmail.com>]

On Saturday, January 5, 2019 at 6:29:11 PM UTC-5, Jere wrote:
> On Friday, January 4, 2019 at 7:20:27 AM UTC-5, George Shapovalov wrote:
> > <SNIPPED>
> > > > Besides linking various type hierarchies together, interfaces are good for containing common code that does not care about specific data storage details.
> > > 
> > > No, interfaces cannot contain common code except for class-wide one. 
> > Yes, I have meant the class-wide methods here of course. Although I must admit I wished more than once that non null/abstract methods that could be inherited and overriden are allowed.  Of course they could only reference other methods (as the data is non-existent at this point), all eventually operating on the abstract/null primitives that are essentially "axioms" of the specific interface. But thus one could provide meaningful abstracted functionality that could be overriden in a sane way, removing the need for  various tricks, one of which you show in your comment. 
> 
> You can using a Mixin Generic along with the interface.  Consider the
> following example:
>   <SNIPPED>

And if you don't like the Mixin method, you can do something a bit closer to
composition and Rust's model (though Ada doesn't support traits, so
it has to be emulated by inheriting an interface instead):

*******************************************

with Ada.Text_IO; use Ada.Text_IO;
procedure Hello is

    package Some_Interface is
    
        type The_Interface is limited interface;
        function f1(Self : The_Interface) return Integer is abstract;
        function f2(Self : The_Interface) return Integer is abstract;
        function f3(Self : The_Interface) return Integer is abstract;
        
        type The_Default is new The_Interface with null record;
        overriding function f1(Self : The_Default) return Integer;
        overriding function f2(Self : The_Default) return Integer;
        overriding function f3(Self : The_Default) return Integer;
        
    end Some_Interface;
    
    package body Some_Interface is
        
        function f1(Self : The_Default) return Integer is
        begin
            return 10;
        end f1;
        function f2(Self : The_Default) return Integer is
        begin
            return 20;
        end f2;
        function f3(Self : The_Default) return Integer is
        begin
            return Self.f1 + Self.f2;
        end f3;
        
    end Some_Interface;
    
    -- For examples using existing inheritance trees we need
    -- a base type
    type Third_Party_Base is tagged null record;
    
    package Examples is
    
        use Some_Interface;
    
        type Example_1 is limited new The_Interface with private;
        overriding function f1(Self : Example_1) return Integer;
        overriding function f2(Self : Example_1) return Integer;
        overriding function f3(Self : Example_1) return Integer;
        
        type Example_2 is new Third_Party_Base and The_Interface with private;
        overriding function f1(Self : Example_2) return Integer;
        overriding function f2(Self : Example_2) return Integer;
        overriding function f3(Self : Example_2) return Integer;
        
    private
        
        -----------------------------------------------
        -- Full Type Declarations
        -----------------------------------------------
        
        type Example_1 is limited new The_Interface with record
            The_Interface_Impl : The_Default;
        end record;
        
        type Example_2 is new Third_Party_Base and The_Interface with record
            The_Interface_Impl : The_Default;
        end record;
    
    end Examples;
    
    package body Examples is
        function f1(Self : Example_1) return Integer is (Self.The_Interface_Impl.f1);
        function f2(Self : Example_1) return Integer is (Self.The_Interface_Impl.f2);
        function f3(Self : Example_1) return Integer is (Self.The_Interface_Impl.f3);
        
        function f1(Self : Example_2) return Integer is (Self.The_Interface_Impl.f1);
        function f2(Self : Example_2) return Integer is (Self.The_Interface_Impl.f2);
        function f3(Self : Example_2) return Integer is (Self.The_Interface_Impl.f3);
    end Examples;

begin
    Put_Line("Hello, world!");
end Hello;

*******************************************

This requires more footwork, but enforces that all
implementors of the interface have to specify a body for all
inherited abstract operations.