Traits and iterators (was: Mixing operators and dot notation)

["Alejandro R. Mosteo" <alejandro@mosteo.com>]

On 06/06/16 10:14, briot.emmanuel@gmail.com wrote:

> We are working on a containers library using this, so that algorithms, for instance,
> can be made independent of containers, and that users can configure a lot of the
> behavior of containers (checks or not, bounded or not, definite or indefine
> elements) by the proper usage of formal package parameters.
> See https://github.com/AdaCore/ada-traits-containers if you want more info.

I've now been going over the documentation and it is very good. It 
clarifies a lot of things that were still a bit muddy in my head.

A question arises (actually a lot of them, sorry for not being clearer 
since I'm lacking the final grasp): if one wants to receive via generics 
a type to which the "of" operator can be applied, what would be the 
minimal signature? Is it doable?

I understand the compiler recognizes such types from the aspects in the 
type declaration (I'm looking at Doubly_Linked_Lists for example) so... 
should the type be descended from some other type having the aspects? 
This example, IIUC, says that: 
http://www.adacore.com/adaanswers/gems/gem-128-iterators-in-ada-2012-part-2/

OTOH, I see the example for the traits containers given as:

generic
    with package Elements is new Elements_Policy (<>);
    type Container is private;
    type Cursor is private;
    with function First (Self : Container) return Cursor is <>;
    with function Has_Element
       (Self : Container; C : Cursor) return Boolean is <>;
    with function Element (C : Cursor) return Elements.Element is <>;
    with procedure Next (C : in out Cursor) is <>;
package Forward_Cursors_Policy is
end Forward_Cursors_Policy;

That, in itself, I don't think will give the ability to use "of" in 
iterations, although it enables one to iterate over an unknown type.

I guess what I'm asking for is what's the simplest way to say that some 
type is "iterable", in the "of"-applicability sense, via generics. 
Another my guess is that, from a Cursors policy package, one could have 
a wrapper type with the proper aspects declared using these subprograms.

Sorry for the barrage of not very clear questions/musings.

Thanks,
Álex.