Add ->set and contains?

docs/api/nfnl/core.md

@@ -2,6 +2,7 @@
 
 **Table of contents**
 
+- [`->set`](#set)
 - [`assoc`](#assoc)
 - [`assoc-in`](#assoc-in)
 - [`boolean?`](#boolean)
@@ -10,6 +11,7 @@
 - [`complement`](#complement)
 - [`concat`](#concat)
 - [`constantly`](#constantly)
+- [`contains?`](#contains)
 - [`count`](#count)
 - [`dec`](#dec)
 - [`distinct`](#distinct)
@@ -58,6 +60,15 @@
 - [`update-in`](#update-in)
 - [`vals`](#vals)
 
+## `->set`
+Function signature:
+
+```
+(->set tbl)
+```
+
+Converts a table `tbl` to a 'set' - which means [:a :b] becomes {:a true :b true}. You can then use contains? to check membership, or just (. my-set :foo) - if that returns true, it's in your set.
+
 ## `assoc`
 Function signature:
 
@@ -138,6 +149,15 @@ Function signature:
 
 Returns a function that takes any number of arguments and returns `v`.
 
+## `contains?`
+Function signature:
+
+```
+(contains? tbl v)
+```
+
+Does the table `tbl` contain the value `v`? If given an associative table it'll check for membership of the key, if given a sequential table it will scan for the value. Associative is essentially O(1), sequential is O(n). You can use `->set` if you need to perform many lookups, it will turn [:a :b] into {:a true :b true} which is O(1) to check.
+
 ## `count`
 Function signature:
 

fnl/nfnl/core.fnl

@@ -454,6 +454,24 @@
           (set done? true))))
     acc))
 
+(fn ->set [tbl]
+  "Converts a table `tbl` to a 'set' - which means [:a :b] becomes {:a true :b true}. You can then use contains? to check membership, or just (. my-set :foo) - if that returns true, it's in your set."
+
+  (when tbl
+    (assert (table? tbl) "Table required as input to ->set.")
+    (let [result {}]
+      (each [_n v (ipairs tbl)]
+        (tset result v true))
+      result)))
+
+(fn contains? [tbl v]
+  "Does the table `tbl` contain the value `v`? If given an associative table it'll check for membership of the key, if given a sequential table it will scan for the value. Associative is essentially O(1), sequential is O(n). You can use `->set` if you need to perform many lookups, it will turn [:a :b] into {:a true :b true} which is O(1) to check."
+  (when tbl
+    (assert (table? tbl) "contains? expects a table")
+    (if (sequential? tbl)
+      (or (some #(= $ v) tbl) false)
+      (= true (. tbl v)))))
+
 {: rand
  : nil?
  : number?
@@ -508,4 +526,6 @@
  : sequential?
  : seq
  : take-while
- : drop-while}
+ : drop-while
+ : ->set
+ : contains?}

fnl/spec/nfnl/core_spec.fnl

@@ -523,3 +523,39 @@
           (assert.are.same nil (core.drop-while #(> $1 0) nil))
           (assert.are.same [] (core.drop-while #(= (. $1 1) :hi) {:hi :world}))
           nil))))
+
+(describe
+  "->set"
+  (fn []
+    (it "ignores nil"
+        (fn []
+          (assert.is_nil (core.->set nil))
+          (assert.is_nil (core.->set))
+          nil))
+
+    (it "it turns sequential tables into associative sets"
+        (fn []
+          (assert.are.same
+            {:a true :b true :c true}
+            (core.->set [:a :b :c]))
+          nil))))
+
+(describe
+  "contains?"
+  (fn []
+    (it "ignores nil"
+        (fn []
+          (assert.is_nil (core.contains? nil :foo))
+          nil))
+
+    (it "works on sequential tables"
+        (fn []
+          (assert.is_true (core.contains? [:foo :bar] :foo))
+          (assert.is_false (core.contains? [:foo :bar] :baz))
+          nil))
+
+    (it "works on associative tables"
+        (fn []
+          (assert.is_true (core.contains? (core.->set [:foo :bar]) :foo))
+          (assert.is_false (core.contains? (core.->set [:foo :bar]) :baz))
+          nil))))