extend string-map API

Author: 9il

source/mir/algebraic_alias/ion.d

@@ -64,6 +64,7 @@ alias IonAlgebraic = Algebraic!Ion_;
 version(mir_test)
 unittest
 {
+    import mir.test: should;
     import mir.ndslice.topology: map;
     import mir.array.allocation: array;
 
@@ -158,6 +159,14 @@ unittest
     assert(fromAA.object["a"] == 3);
     assert(fromAA.object["b"] == "b");
 
+    // object foreach iteration
+    long sum;
+    foreach (ref key, ref val; fromAA.object)
+        if (key == "a")
+            sum += val.get!long;
+    sum.should == 3;
+
+    // annotations
     auto annotated = Annotated!IonAlgebraic(["birthday"], Timestamp("2001-01-01"));
     value = annotated;
     assert(value == annotated);

source/mir/algebraic_alias/json.d

@@ -49,6 +49,7 @@ version(mir_test)
 @safe pure
 unittest
 {
+    import mir.test: should;
     import mir.ndslice.topology: map;
     import mir.array.allocation: array;
 
@@ -141,4 +142,11 @@ unittest
     JsonAlgebraic fromAA = ["a" : JsonAlgebraic(3), "b" : JsonAlgebraic("b")];
     assert(fromAA.object["a"] == 3);
     assert(fromAA.object["b"] == "b");
+
+    // object foreach iteration
+    long sum;
+    foreach (ref key, ref val; fromAA.object)
+        if (key == "a")
+            sum += val.get!long;
+    sum.should == 3;
 }

source/mir/string_map.d

@@ -258,6 +258,14 @@ struct StringMap(T)
         return implementation ? implementation.length : 0;
     }
 
+    /++
+    Returns: number of elements in the table.
+    +/
+    bool empty()() @safe pure nothrow @nogc const @property
+    {
+        return !implementation || implementation.length == 0;
+    }
+
     version(mir_test) static if (is(T == int))
     ///
     @safe pure unittest
@@ -345,8 +353,8 @@ struct StringMap(T)
     */
     auto byKeyValue(this This)() @trusted pure nothrow @nogc
     {
-        import mir.ndslice.topology: zip, map;
-        return keys.zip(values).map!KeyValue;
+        import mir.ndslice.topology: map;
+        return this.opIndex.map!KeyValue;
     }
 
     version(mir_test) static if (is(T == int))
@@ -369,6 +377,19 @@ struct StringMap(T)
         assert(map.values == [4.0]);
     }
 
+    ///
+    auto opIndex(this This)() @trusted pure nothrow @nogc
+    {
+        import mir.ndslice.topology: zip;
+        return keys.zip(values);
+    }
+
+    ///
+    auto dup(this This)() @trusted
+    {
+        return StringMap(keys.dup, values.dup);
+    }
+
     /++
     (Property) Gets the current capacity of an associative array.
     The capacity is the size that the underlaynig slices can grow to before the underlying arrays may be reallocated or extended.
@@ -688,7 +709,7 @@ struct StringMap(T)
 
     Complexity: `O(log(s))`, where `s` is the number of the keys with the same length as the input key.
     +/
-    inout(T) get()(scope const(char)[] key, lazy inout(T) defaultValue)
+    inout(T) get()(scope const(char)[] key, lazy inout(T) defaultValue) inout
     {
         size_t index;
         if (implementation && implementation.findIndex(key, index))
@@ -808,6 +829,7 @@ struct StringMap(T)
     }
 
     ///
+    version(mir_test) static if (is(T == int))
     @safe pure nothrow unittest
     {
         StringMap!int map = ["k": 1];
@@ -971,22 +993,22 @@ struct StringMap(T)
             return _length;
         }
 
-        inout(string)[] keys()() @trusted inout @property
+        inout(string)[] keys()() @trusted inout @property pure @nogc nothrow
         {
             return _keys[0 .. _length];
         }
 
-        inout(T)[] values()() @trusted inout @property
+        inout(T)[] values()() @trusted inout @property pure @nogc nothrow
         {
             return _values[0 .. _length];
         }
 
-        inout(U)[] indices()() @trusted inout @property
+        inout(U)[] indices()() @trusted inout @property pure @nogc nothrow
         {
             return _indices[0 .. _length];
         }
 
-        inout(U)[] lengthTable()() @trusted inout @property
+        inout(U)[] lengthTable()() @trusted inout @property pure @nogc nothrow
         {
             return _lengthTable;
         }
@@ -1217,3 +1239,62 @@ version(mir_test)
 
     assert((*tkType) == "Bearer"); // *tkType contains value 3599
 }
+
+///
+template intersectionMap(alias merger)
+{
+    ///
+    StringMap!V intersectionMap(V)(StringMap!V a, StringMap!V b)
+    {
+        import mir.functional : naryFun;
+        typeof(return) res;
+        foreach (key, ref value; a)
+            if (auto bValPtr = key in b)
+                res[key] = naryFun!merger(value, *bValPtr);
+        return res;
+    }
+}
+
+///
+version(mir_test)
+@safe pure
+unittest {
+    import mir.test: should;
+    import mir.string_map : StringMap;
+    auto m0 = StringMap!int(["foo", "bar"], [1, 2]);
+    auto m1 = StringMap!int(["foo"], [2]);
+    auto m2 = StringMap!int(["foo"], [3]);
+    intersectionMap!"a + b"(m0, m1).should == m2;
+}
+
+///
+template unionMap(alias merger)
+{
+    ///
+    StringMap!V unionMap(V)(StringMap!V a, StringMap!V b)
+    {
+        import mir.functional : naryFun;
+        typeof(return) res;
+        foreach (key, ref value; a)
+            if (auto bValPtr = key in b)
+                res[key] = naryFun!merger(value, *bValPtr);
+            else
+                res[key] = value;
+        foreach (key, ref value; b)
+            if (key !in res)
+                res[key] = value;
+        return res;
+    }
+}
+
+///
+version(mir_test)
+@safe pure
+unittest {
+    import mir.test: should;
+    import mir.string_map : StringMap;
+    auto m0 = StringMap!int(["foo", "bar"], [1, 2]);
+    auto m1 = StringMap!int(["foo"], [2]);
+    auto m2 = StringMap!int(["foo", "bar"], [3, 2]);
+    unionMap!"a + b"(m0, m1).should == m2;
+}