Add Map library code.

Author: jemc

LICENSE.md

@@ -1,4 +1,4 @@
-Copyright 2018 Joe Eli McIlvain
+Copyright 2019 Joe Eli McIlvain
 
 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 

manifest.savi

@@ -0,0 +1,9 @@
+:manifest lib Map
+  :sources "src/*.savi"
+
+:manifest bin "spec"
+  :copies Map
+  :sources "spec/*.savi"
+
+  :dependency Spec v0
+    :depends on Map

spec/Main.savi

@@ -0,0 +1,7 @@
+:actor Main
+  :new (env)
+    Spec.Process.run(env, [
+      Spec.Run(Map.Spec).new(env)
+      Spec.Run(Map.Ordered.Spec).new(env)
+      Spec.Run(Map.Readable.Spec).new(env)
+    ])

spec/Map.Spec.savi

@@ -0,0 +1,81 @@
+:actor _MapElementExampleActor
+
+:class Map.Spec
+  :is Spec
+  :const describes: "Map"
+
+  :fun new_map: Map(String, U64).new
+  :fun new_actor_map: Map.ByIdentity(_MapElementExampleActor, U64).new
+
+  :it "stores and removes values at a given key"
+    map = @new_map
+    assert: map.size == 0
+    assert error: map["example"]!
+    assert: map.has_key("example").is_false
+    assert: (map["example"] = 99) == 99
+    assert: map.size == 1
+    assert: map["example"]! == 99
+    assert: map.has_key("example")
+    assert: (map["example"] = 88) == 88
+    assert: map.size == 1
+    assert: map["example"]! == 88
+    assert: map.has_key("example")
+    assert: map.delete("example") <: None
+    assert error: map["example"]!
+    assert: map.has_key("example").is_false
+    assert: map.size == 0
+
+  :it "stores values at actor keys by identity"
+    foo = _MapElementExampleActor.new
+    bar = _MapElementExampleActor.new
+    baz = _MapElementExampleActor.new
+    map = @new_actor_map
+    map[foo] = 11
+    map[bar] = 22
+    map[baz] = 33
+    assert: map[foo]! == 11
+    assert: map[bar]! == 22
+    assert: map[baz]! == 33
+
+  :it "can be cleared, removing all keys and values"
+    map = @new_map
+    map["foo"] = 11
+    map["bar"] = 22
+    map["baz"] = 33
+
+    assert: map.size == 3, map.clear
+    assert: map.size == 0
+
+  :it "yields each key and value"
+    map = @new_map
+    map["foo"] = 11
+    map["bar"] = 22
+    map["baz"] = 33
+
+    copy = @new_map
+    map.each -> (key, value | copy[key] = value)
+
+    assert: copy.size == 3
+    assert: copy["foo"]! == 11
+    assert: copy["bar"]! == 22
+    assert: copy["baz"]! == 33
+
+  :it "yields each key and value until the criteria is met"
+    map = @new_map
+    map["foo"] = 11
+    map["bar"] = 22
+    map["baz"] = 33
+
+    this_key = ""
+    found_it = map.each_until -> (key, value | this_key = key, value == 22)
+    assert: found_it
+    assert: this_key == "bar"
+
+    this_key = ""
+    found_it = map.each_until -> (key, value | this_key = key, value == 33)
+    assert: found_it
+    assert: this_key == "baz"
+
+    this_key = ""
+    found_it = map.each_until -> (key, value | this_key = key, value == 99)
+    assert: found_it.is_false

spec/Ordered.Spec.savi

@@ -0,0 +1,75 @@
+:class Map.Ordered.Spec
+  :is Spec
+  :const describes: "Map.Ordered"
+
+  :fun new_map: Map.Ordered(String, U64).new
+
+  :it "stores and removes values at a given key"
+    map = @new_map
+    assert: map.size == 0
+    assert error: map["example"]!
+    assert: map.has_key("example").is_false
+    assert: (map["example"] = 99) == 99
+    assert: map.size == 1
+    assert: map["example"]! == 99
+    assert: map.has_key("example")
+    assert: (map["example"] = 88) == 88
+    assert: map.size == 1
+    assert: map["example"]! == 88
+    assert: map.has_key("example")
+    assert: map.delete("example") <: None
+    assert error: map["example"]!
+    assert: map.has_key("example").is_false
+    assert: map.size == 0
+
+  :it "can be cleared, removing all keys and values"
+    map = @new_map
+    map["foo"] = 11
+    map["bar"] = 22
+    map["baz"] = 33
+
+    assert: map.size == 3, map.clear
+    assert: map.size == 0
+
+  :it "yields each key and value (in insertion order)"
+    map = @new_map
+    map["foo"] = 11
+    map["bar"] = 22
+    map["baz"] = 33
+    map["foo"] = 44
+    map["baz"] = 55
+    map["foo"] = 66
+
+    keys Array(String) = []
+    values Array(U64) = []
+    map.each -> (key, value | keys << key, values << value)
+
+    assert: keys == ["bar", "baz", "foo"]
+    assert: values == [22, 55, 66]
+
+  :it "yields each key and value until the criteria is met"
+    map = @new_map
+    map["foo"] = 11
+    map["bar"] = 22
+    map["baz"] = 33
+
+    count = USize[0]
+    key = ""
+    found_it = map.each_until -> (k, v | count += 1, key = k, v == 22)
+    assert: found_it
+    assert: count == 2
+    assert: key == "bar"
+
+    count = USize[0]
+    key = ""
+    found_it = map.each_until -> (k, v | count += 1, key = k, v == 33)
+    assert: found_it
+    assert: count == 3
+    assert: key == "baz"
+
+    count = USize[0]
+    key = ""
+    found_it = map.each_until -> (k, v | count += 1, key = k, v == 99)
+    assert: count == 3
+    assert: key == "baz"
+    assert: found_it.is_false

spec/Readable.Spec.savi

@@ -0,0 +1,78 @@
+:class Map.Readable.Spec
+  :is Spec
+  :const describes: "Map.Readable"
+
+  :fun new_mutable_map: Map(String, U64).new
+
+  :: Create a mutable map, yield it to the caller for initialization,
+  :: then return it as read-only using the Map.Readable trait as the type.
+  :: This ensures that we are testing based only on the trait's methods,
+  :: while still giving us a temporary time of mutability to initialize it.
+  :fun build_map Map.Readable(String, U64)
+    map = @new_mutable_map
+    yield map
+    map
+
+  :it "yields each key and each value (separately)"
+    map = @build_map -> (map |
+      map["foo"] = 11
+      map["bar"] = 22
+      map["baz"] = 33
+    )
+
+    copy = @new_mutable_map
+    map.each_key -> (key | try (copy[key] = map[key]!))
+
+    assert: copy.size == 3
+    assert: copy["foo"]! == 11
+    assert: copy["bar"]! == 22
+    assert: copy["baz"]! == 33
+
+    total_value = U64[0]
+    map.each_value -> (value | total_value += value)
+    assert: total_value == 66
+
+  :it "yields each key and each value (separately) until the criteria is met"
+    map = @build_map -> (map |
+      map["foo"] = 11
+      map["bar"] = 22
+      map["baz"] = 33
+    )
+
+    this_key = ""
+    found_it = map.each_key_until -> (key | this_key = key, key.ends_with("o"))
+    assert: found_it
+    assert: this_key == "foo"
+
+    this_key = ""
+    found_it = map.each_key_until -> (key | this_key = key, key.ends_with("z"))
+    assert: found_it
+    assert: this_key == "baz"
+
+    this_key = ""
+    found_it = map.each_key_until -> (key | this_key = key, key.ends_with("x"))
+    assert: found_it.is_false
+
+  :it "checks if any pair in the map meets the given condition"
+    map = @build_map -> (map |
+      map["foo"] = 11
+      map["bar"] = 22
+      map["baz"] = 33
+    )
+
+    assert: map.has_any -> (key, value | key == "foo")
+    assert: map.has_any -> (key, value | key == "food").is_false
+    assert: map.has_any -> (key, value | value == 22)
+    assert: map.has_any -> (key, value | value == 23).is_false
+
+  :it "checks if all pairs in the map meet the given condition"
+    map = @build_map -> (map |
+      map["foo"] = 11
+      map["bar"] = 22
+      map["baz"] = 33
+    )
+
+    assert: map.has_all -> (key, value | key.size == 3)
+    assert: map.has_all -> (key, value | key.starts_with("ba")).is_false
+    assert: map.has_all -> (key, value | value < 50)
+    assert: map.has_all -> (key, value | value < 30).is_false