Rename private std.typecons.isConceptWith to implementsInterface

Author: JesseKPhillips

std/typecons.d

@@ -3873,22 +3873,22 @@ unittest
  * Determines if the $(D Source) type satisfies all interface requirements of
  * $(D Targets).
  */
-private template isConceptWith(Source, Targets...)
+private template implementsInterface(Source, Targets...)
 if (Targets.length >= 1 && allSatisfy!(isMutable, Targets))
 {
     import std.typetuple : staticMap;
 
     // strict upcast
-    auto isConceptWith()() @safe pure nothrow
+    auto implementsInterface()() @safe pure nothrow
     if (Targets.length == 1 && is(Source : Targets[0]))
     {
         return true;
     }
     // structural upcast
-    template isConceptWith()
+    template implementsInterface()
     if (!allSatisfy!(Bind!(isImplicitlyConvertible, Source), Targets))
     {
-        auto isConceptWith()
+        auto implementsInterface()
         {
             return hasRequireMethods!();
         }
@@ -3914,12 +3914,12 @@ if (Targets.length >= 1 && allSatisfy!(isMutable, Targets))
     }
 }
 /// ditto
-private template isConceptWith(Source, Targets...)
+private template implementsInterface(Source, Targets...)
 if (Targets.length >= 1 && !allSatisfy!(isMutable, Targets))
 {
     import std.typetuple : staticMap;
 
-    alias isConceptWith = .isConceptWith!(Source, staticMap!(Unqual, Targets));
+    alias implementsInterface = .implementsInterface!(Source, staticMap!(Unqual, Targets));
 }
 
 unittest {
@@ -3950,22 +3950,22 @@ unittest {
         void foobar() {}
     }
     // Implements interface
-    static assert(isConceptWith!(A, Foo));
-    static assert(isConceptWith!(A, const(Foo)));
-    static assert(isConceptWith!(A, immutable(Foo)));
+    static assert(implementsInterface!(A, Foo));
+    static assert(implementsInterface!(A, const(Foo)));
+    static assert(implementsInterface!(A, immutable(Foo)));
     // Doesn't implement interface
-    static assert(!isConceptWith!(B, Foo));
-    static assert(isConceptWith!(B, Bar));
+    static assert(!implementsInterface!(B, Foo));
+    static assert(implementsInterface!(B, Bar));
     // Implements both interfaces
-    static assert(isConceptWith!(C, Foo));
-    static assert(isConceptWith!(C, Bar));
-    static assert(isConceptWith!(C, Foo, Bar));
-    static assert(isConceptWith!(C, Foo, const(Bar)));
-    static assert(!isConceptWith!(A, Foo, Bar));
-    static assert(!isConceptWith!(A, Foo, immutable(Bar)));
+    static assert(implementsInterface!(C, Foo));
+    static assert(implementsInterface!(C, Bar));
+    static assert(implementsInterface!(C, Foo, Bar));
+    static assert(implementsInterface!(C, Foo, const(Bar)));
+    static assert(!implementsInterface!(A, Foo, Bar));
+    static assert(!implementsInterface!(A, Foo, immutable(Bar)));
     // Implements inherited
-    static assert(isConceptWith!(D, FooBar));
-    static assert(!isConceptWith!(B, FooBar));
+    static assert(implementsInterface!(D, FooBar));
+    static assert(!implementsInterface!(B, FooBar));
 }
 
 private template isInterface(ConceptType) {
@@ -3998,7 +3998,7 @@ if (Targets.length >= 1 && allSatisfy!(isMutable, Targets)
     {
         auto wrap(inout Source src)
         {
-            static assert(isConceptWith!(Source, Targets),
+            static assert(implementsInterface!(Source, Targets),
                           "Source "~Source.stringof~
                           " does not have structural conformance to "~
                           Targets.stringof);