Add String.opEquals(AA) (#379)

* Limit imports of emplaceRef

* Add String.opEquals(AA)

* Make opEquals tests more extensive

* Fix syntax error

* Adjust logic for computing index in StringMap.opEquals

* Improve opEquals test to increase coverage

* Add more asserts

* Correct comment

* Simplify opEquals

* Qualify K and V part of opEquals(AA) as const

* Simplify StringMap.opEquals to use array comparison

* Simplify StringMap.opEquals further

Author: nordlow

source/mir/string_map.d

@@ -42,7 +42,7 @@ struct StringMap(T, U = uint)
     {
         // NOTE: moving this to template restriction fails with recursive template instanation
         static assert(is(typeof(T.init == V.init) : bool),
-                      "Unsupported rhs of type " ~ typeof(rhs).stringof); // TODO:
+                      "Unsupported rhs of type " ~ typeof(rhs).stringof);
         if (keys != rhs.keys)
             return false;
         if (implementation)
@@ -51,6 +51,27 @@ struct StringMap(T, U = uint)
                     return false;
         return true;
     }
+    /// ditto
+    bool opEquals(K, V)(scope const const(V)[const(K)] rhs) const
+    if (is(typeof(K.init == string.init) : bool) &&
+        is(typeof(V.init == T.init) : bool))
+    {
+        if (implementation is null)
+            return rhs.length == 0;
+        if (implementation._length != rhs.length)
+            return false;
+        foreach (const i; 0 .. implementation._length)
+        {
+            if (const valuePtr = implementation.keys[i] in rhs)
+            {
+                if (*valuePtr != implementation.values[i])
+                    return false;
+            }
+            else
+                return false;
+        }
+        return true;
+    }
 
     // // linking bug
     // version(none)
@@ -658,7 +679,7 @@ struct StringMap(T, U = uint)
     }
 
     /++
-    Converts the associtave array to a common Dlang associative array.
+    Converts to a builtin associative array.
 
     Complexity: `O(n)`.
     +/
@@ -711,7 +732,6 @@ struct StringMap(T, U = uint)
         assert(aa["k"] == 1);
     }
 
-
     private static struct Impl
     {
         import core.lifetime: move;
@@ -954,17 +974,36 @@ version(mir_test)
 ///
 @safe unittest
 {
-    StringMap!int x;
-    x["L"] = 3;
-    x["A"] = 2;
-    x["val"] = 1;
-
-    StringMap!uint y;
-    y["L"] = 3;
-    y["A"] = 2;
-    y["val"] = 1;
+    static void testEquals(X, Y)()
+    {
+        X x;
+        Y y;
+        assert(x == y);
+
+        x["L"] = 3;
+        assert(x != y);
+        x["A"] = 2;
+        assert(x != y);
+        x["val"] = 1;
+        assert(x != y);
+
+        y["L"] = 3;
+        assert(x != y);
+        y["A"] = 2;
+        assert(x != y);
+        y["val"] = 1;
+        assert(x == y);
+
+        x = X.init;
+        assert(x != y);
+
+        y = Y.init;
+        assert(x == y);
+    }
 
-    assert(x == y);
+    testEquals!(StringMap!int, StringMap!uint)();
+    testEquals!(StringMap!int, uint[string])();
+    testEquals!(uint[string], StringMap!int)();
 }
 
 version(mir_test)