passing duck-typed objects and retaining full type information

[Freddy via Digitalmars-d-learn]

On Tuesday, 11 November 2014 at 19:23:39 UTC, Adam Taylor wrote:
> * i apologize in advance, this is my first post -- the code 
> formatting probably wont turn out so great...
>
> I have a bunch of duck typed interfaces for "containers" 
> similar to what you would find in std.range.
>
> i.e.
> template isContainer(C)
> {
>     enum bool isContainer = is(typeof(
>     (inout int = 0)
>     {
>         C c = C.init;
> 	...					
>     }));
> }
>
> template canRemoveFromContainer(C)
> {
>     enum bool canRemoveFromContainer = isContainer!C && 
> is(typeof(
>     (inout int = 0)
>     {
>         C c = C.init;
>         c.remove();
>     }));
> }
>
> Now what i want to do is pass some such "container" object to 
> an interface function:
>
> interface MyInterface
> {
> void filterCollisions(S)(S collisionCandidates)
>     if(canRemoveFromContainer!S)
> }
>
> but of coarse templates and interfaces don't get along so well.
>  so...so far as I know i would need to do something like this:
>
>
> interface MyInterface
> {
> final void filterCollisions(S)(S collisionCandidates)
>     if(canRemoveFromContainer!S)
> {
> filterCollisionsImpl(...);
> }
>
> void filterCollisionsImpl(...)
>
> }
>
>
> and pass something to filterCollisionsImpl that is a "proper" 
> class or interface type.
>
> So here's the problem:  many of the "duck-typed" interfaces 
> cannot be converted to proper interfaces without losing 
> something.  So is there ANY way to pass in
> a very basic class or interface Container type and call the 
> remove function on it?  Here's what i've tried:
>
> interface Container(C)
> {
> ...
> }
>
> template ContainerObject(C) if (isContainer!(Unqual!C)) {
>     static if (is(C : Container!(ElementType!C))) {
>         alias ContainerObject = C;
>     } else static if (!is(Unqual!C == C)) {
>         alias ContainerObject = ContainerObject!(Unqual!C);
>     } else {
>
>     	static if (__traits(compiles, { enum e = C.ValueType; })) {
>           alias ValueType = C.ValueType;
> 	} else {
> 	  alias ValueType = ElementType!C;
> 	}
> 		
>         class ContainerObject : Container!ValueType {
>             C _container;
>
>             this(C container) {
>                 this._container = container;
>             }
>
>             static if(canRemoveFromContainer!C) {
>               size_t remove()
> 	      {
> 	        return _container.remove();
> 	      }
>             }
>         }
>     }
> }
>
> ContainerObject!C containerObject(C)(C container) if 
> (isContainer!C) {
>     static if (is(C : Container!(ElementType!C))) {
>         return container;
>     } else {
>         return new ContainerObject!C(container);
>     }
> }
>
>
> interface MyInterface
> {
> final void filterCollisions(S)(S collisionCandidates)
>     if(canRemoveFromContainer!S)
> {
>   auto container = containerObject(collisionCandidates);
>   container.remove();  // works just fine -- have the complete 
> type info at instantiation site
>   filterCollisionsImpl();
> }
>
> void filterCollisionsImpl(Container!string collisionCandidates)
> collisionCandidates.remove(); // error -- some type info is 
> lost here, only have a Container!string which doesn't have a 
> remove function.
> }
Not entirly sure of what you asking for,but have you tried
inhertance?
----
interface Base(C){
      /+...+/
}

interface Derived(C):Base!C{
      /+...+/
}
----