set.take

Author: lpil

CHANGELOG.md

@@ -6,7 +6,7 @@
   `from_list`, `fold`, `run`, `to_list`, `take`, `drop`, `map`, `filter`,
   `cycle`, and `range` functions.
 - Created the `set` module with the `new`, `insert`, `delete`, `to_list`,
-  `from_list`, `fold`, and `contains` functions.
+  `from_list`, `fold`, `take`, and `contains` functions.
 - Created the `io` module with the `print`, `println`, and `debug` functions.
 - Created the `queue` module with the `new`, `from_list`, `to_list`,
   `is_empty`, `length`, `push_back`, `push_front`, `pop_back`, `pop_front`,
@@ -29,6 +29,7 @@
 - The `list.sort` label `sort_by` has been changed to `by`.
 - The `list.fold`'s first argument gained the label `over`.
 - The `map.fold`'s first argument gained the label `over`.
+- The `map.take`'s `drop` arguement has been changed to `keeping`.
 
 ## v0.8.0 - 2020-04-28
 

src/gleam/map.gleam

@@ -179,8 +179,8 @@ external fn erl_filter(
 ///    > |> filter(fn(key, value) { True })
 ///    from_list([tuple("a", 0), tuple("b", 1)])
 ///
-pub fn filter(in map: Map(k, v), for predicate: fn(k, v) -> Bool) -> Map(k, v) {
-  erl_filter(predicate, map)
+pub fn filter(in map: Map(k, v), for property: fn(k, v) -> Bool) -> Map(k, v) {
+  erl_filter(property, map)
 }
 
 external fn erl_take(List(k), Map(k, v)) -> Map(k, v) =
@@ -199,7 +199,7 @@ external fn erl_take(List(k), Map(k, v)) -> Map(k, v) =
 ///    > |> take(["a", "b", "c"])
 ///    from_list([tuple("a", 0), tuple("b", 1)])
 ///
-pub fn take(from map: Map(k, v), drop desired_keys: List(k)) -> Map(k, v) {
+pub fn take(from map: Map(k, v), keeping desired_keys: List(k)) -> Map(k, v) {
   erl_take(desired_keys, map)
 }
 

src/gleam/set.gleam

@@ -132,3 +132,40 @@ pub fn fold(
 ) -> acc {
   map.fold(over: set.map, from: initial, with: fn(k, _, a) { reducer(k, a) })
 }
+
+/// Create a new set from an existing set, minus any members that a given
+/// function returns False for.
+///
+/// This function runs in loglinear time.
+///
+/// ## Examples
+///
+///    > import gleam/int
+///    > from_list([1, 4, 6, 3, 675, 44, 67])
+///    > |> filter(for: int.is_even)
+///    > |> to_list
+///    [4, 6, 44]
+///
+pub fn filter(
+  in set: Set(member),
+  for property: fn(member) -> Bool,
+) -> Set(member) {
+  Set(map.filter(in: set.map, for: fn(m, _) { property(m) }))
+}
+
+/// Create a new map from a given map, only including any members which are in
+/// a given list.
+///
+/// This function runs in loglinear time.
+///
+/// ## Examples
+///
+///    > from_list([1, 2, 3]) |> take([1, 3, 5]) |> to_list
+///    [1, 3]
+///
+pub fn take(
+  from set: Set(member),
+  keeping desired: List(member),
+) -> Set(member) {
+  Set(map.take(from: set.map, keeping: desired))
+}

test/gleam/set_test.gleam

@@ -56,11 +56,26 @@ pub fn from_list_test() {
   |> set.from_list
   |> set.to_list
   |> list.sort(by: int.compare)
-  |> should.equal([1, 3, 3, 4])
+  |> should.equal([1, 2, 3, 4])
 }
 
 pub fn fold_test() {
   [1, 3, 9]
   |> set.from_list
   |> set.fold(from: 0, with: fn(m, a) { m + a })
 }
+
+pub fn filter_test() {
+  [1, 4, 6, 3, 675, 44, 67]
+  |> set.from_list()
+  |> set.filter(for: int.is_even)
+  |> set.to_list
+  |> should.equal([4, 6, 44])
+}
+
+pub fn take_test() {
+  [1, 2, 3]
+  |> set.from_list
+  |> set.take([1, 3, 5])
+  |> should.equal(set.from_list([1, 3]))
+}