Added the memoize core fn (#813)

Hi,

could you please consider an implementation of the `memoize` core fn. It
fixes #812.

Also added some basic tests.

Thanks

Co-authored-by: ikappaki <[email protected]>
Co-authored-by: Chris Rink <[email protected]>

Author: ikappaki

CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  * Added support for autocompleting names in the `python/` pseudo-namespace for Python builtins at the REPL (#787)
  * Added a subcommand for bootstrapping the Python installation with Basilisp (#790)
  * Added support for executing Basilisp namespaces directly via `basilisp run` and by `python -m` (#791)
+ * Added the `memoize` core fn (#812)
 
 ### Changed
  * Optimize calls to Python's `operator` module into their corresponding native operators (#754)

src/basilisp/core.lpy

@@ -3321,6 +3321,19 @@
              (concat '(fn* []) [expr]))
            exprs)))
 
+(defn memoize
+  "Retuns a fn that caches the results of the previous invocations of
+  `f`. The memoized fn keeps a cache of the mapping from arguments to
+  results."
+  [f]
+  (let [cache (atom {})]
+    (fn [& args]
+      (if-let [kv (find @cache args)]
+        (second kv)
+        (let [res (apply f args)]
+          (swap! cache assoc args res)
+          res)))))
+
 ;;;;;;;;;;;;;;;;;;;;;;
 ;; Random Functions ;;
 ;;;;;;;;;;;;;;;;;;;;;;

tests/basilisp/prompt_test.py

@@ -75,6 +75,7 @@ def patch_completions(self, completions: Iterable[str]):
                     "max",
                     "max-key",
                     "memfn",
+                    "memoize",
                     "merge",
                     "meta",
                     "methods",

tests/basilisp/test_core_fns.lpy

@@ -1082,6 +1082,29 @@
     '(((1 2 (3)) (4)) (1 2 (3)) 1 2 (3) 3 (4) 4)                             seq? identity '((1 2 (3)) (4))
     '((:A (:B (:D) (:E)) (:C (:F))) (:B (:D) (:E)) (:D) (:E) (:C (:F)) (:F)) next rest     '(:A (:B (:D) (:E)) (:C (:F)))))
 
+(deftest memoize-test
+  (testing "single args"
+    (let [m1 (memoize (fn [a] (str a (random-uuid))))
+          a1 (m1 :a)
+          a2 (m1 :b)
+          an (m1 nil)]
+      (is (= a1 (m1 :a)))
+      (is (= a2 (m1 :b)))
+      (is (= an (m1 nil)))
+      (is (distinct? a1 a2 an))))
+
+  (testing "variadic"
+    (let [m1 (memoize (fn [& more] (str more (random-uuid))))
+          a0 (m1)
+          a1 (m1 :a)
+          a2 (m1 :a '(xyz))
+          an (m1 nil)]
+      (is (= a0 (m1)))
+      (is (= a1 (m1 :a)))
+      (is (= a2 (m1 :a '(xyz))))
+      (is (= an (m1 nil)))
+      (is (distinct? a0 a1 a2 an)))))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Associative Functions ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;