map_dict:Map -> map:MapDict, map_dict:take

Author: lpil

CHANGELOG.md

@@ -4,6 +4,8 @@
 
 - `list` module gains `at`, `all`, `any`, `index_map`, `intersperse`, `sort`,
   `unique`, and `zip` functions.
+- `map_dict:Map` renamed to `map_dict:MapDict`.
+- `map_dict` module gains `take`.
 - `str` module gains `append`.
 
 ## v0.1.1 - 2019-04-17

gen/src/map_dict.erl

@@ -1,7 +1,7 @@
 -module(map_dict).
 -compile(no_auto_import).
 
--export([size/1, to_list/1, from_list/1, has_key/2, new/0, fetch/2, put/3, map_values/2, keys/1, values/1, filter/2]).
+-export([size/1, to_list/1, from_list/1, has_key/2, new/0, fetch/2, put/3, map_values/2, keys/1, values/1, filter/2, take/2]).
 
 size(A) ->
     maps:size(A).
@@ -47,3 +47,9 @@ erl_filter(A, B) ->
 
 filter(Map, Fun) ->
     erl_filter(Fun, Map).
+
+erl_take(A, B) ->
+    maps:with(A, B).
+
+take(Map, Keys) ->
+    erl_take(Keys, Map).

gen/test/map_dict_test.erl

@@ -1,7 +1,7 @@
 -module(map_dict_test).
 -compile(no_auto_import).
 
--export([from_list_test/0, has_key_test/0, new_test/0, fetch_test/0, put_test/0, map_values_test/0, keys_test/0, values_test/0]).
+-export([from_list_test/0, has_key_test/0, new_test/0, fetch_test/0, put_test/0, map_values_test/0, keys_test/0, values_test/0, take_test/0]).
 
 from_list_test() ->
     expect:equal(map_dict:size(map_dict:from_list([{4, 0}, {1, 0}])), 2).
@@ -53,3 +53,10 @@ values_test() ->
                                                      {<<"b">>, 1},
                                                      {<<"c">>, 2}])),
                  [0, 1, 2]).
+
+take_test() ->
+    expect:equal(map_dict:take(map_dict:from_list([{<<"a">>, 0},
+                                                   {<<"b">>, 1},
+                                                   {<<"c">>, 2}]),
+                               [<<"a">>, <<"b">>, <<"d">>]),
+                 map_dict:from_list([{<<"a">>, 0}, {<<"b">>, 1}])).

src/map_dict.gleam

@@ -2,59 +2,66 @@ import any
 import result
 
 // TODO: drop
-// TODO: take
-// TODO: update :: fn(Map(k, v), k, fn(Result(v, NotFound)) -> v) -> Map(k, v)
+// TODO: update :: fn(MapDict(k, v), k, fn(Result(v, NotFound)) -> v) -> MapDict(k, v)
 
-pub external type Map(key, value);
+pub external type MapDict(key, value);
 
 pub enum NotFound =
   | NotFound
 
-pub external fn size(Map(k, v)) -> Int
+pub external fn size(MapDict(k, v)) -> Int
   = "maps" "size"
 
-pub external fn to_list(Map(key, value)) -> List({key, value})
+pub external fn to_list(MapDict(key, value)) -> List({key, value})
   = "maps" "to_list"
 
-pub external fn from_list(List({key, value})) -> Map(key, value)
+pub external fn from_list(List({key, value})) -> MapDict(key, value)
   = "maps" "from_list"
 
-external fn is_key(key, Map(key, v)) -> Bool
+external fn is_key(key, MapDict(key, v)) -> Bool
   = "maps" "is_key"
 
 pub fn has_key(map, key) {
   is_key(key, map)
 }
 
-pub external fn new() -> Map(key, value)
+pub external fn new() -> MapDict(key, value)
   = "maps" "new"
 
-pub external fn fetch(Map(key, value), key) -> Result(value, NotFound)
+pub external fn fetch(MapDict(key, value), key) -> Result(value, NotFound)
   = "gleam__stdlib" "map_fetch";
 
-external fn erl_put(key, value, Map(key, value)) -> Map(key, value)
+external fn erl_put(key, value, MapDict(key, value)) -> MapDict(key, value)
   = "maps" "put";
 
 pub fn put(map, key, value) {
   erl_put(key, value, map)
 }
 
-external fn erl_map_values(fn(key, value) -> value, Map(key, value)) -> Map(key, value)
+external fn erl_map_values(fn(key, value) -> value, MapDict(key, value))
+  -> MapDict(key, value)
   = "maps" "map";
 
 pub fn map_values(map, fun) {
   erl_map_values(fun, map)
 }
 
-pub external fn keys(Map(keys, v)) -> List(keys)
+pub external fn keys(MapDict(keys, v)) -> List(keys)
   = "maps" "keys"
 
-pub external fn values(Map(k, values)) -> List(values)
+pub external fn values(MapDict(k, values)) -> List(values)
   = "maps" "values"
 
-external fn erl_filter(fn(key, value) -> Bool, Map(key, value)) -> Map(key, value)
+external fn erl_filter(fn(key, value) -> Bool, MapDict(key, value))
+  -> MapDict(key, value)
   = "maps" "filter";
 
 pub fn filter(map, fun) {
   erl_filter(fun, map)
 }
+
+external fn erl_take(List(k), MapDict(k, v)) -> MapDict(k, v) = "maps" "with"
+
+pub fn take(map, keys) {
+  erl_take(keys, map)
+}

test/map_dict_test.gleam

@@ -111,3 +111,14 @@ pub fn values_test() {
     |> map_dict:values
     |> expect:equal(_, [0, 1, 2])
 }
+
+pub fn take_test() {
+  [
+    {"a", 0},
+    {"b", 1},
+    {"c", 2},
+  ]
+    |> map_dict:from_list
+    |> map_dict:take(_, ["a", "b", "d"])
+    |> expect:equal(_, map_dict:from_list([{"a", 0}, {"b", 1}]))
+}