Add support for taps (#631)

* Combine all imports in basilisp.core

* More import statement fixes

* Add support for taps

* Spell better

* Tests

* Oop

* Add some random other functions I just found

* Fix weird test runner bug

* Yes

* More test cases

Author: chrisrink10

CHANGELOG.md

@@ -8,9 +8,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
  * Added a bootstrapping function for easily bootstrapping Basilisp projects from Python (#620)
  * Added support for watchers and validator functions on Atoms and Vars (#627)
+ * Added support for Taps (#631)
 
 ### Changed
  * PyTest is now an optional extra dependency, rather than a required dependency (#622)
+ * Generated Python functions corresponding to nested functions are now prefixed with the containing function name, if one exists (#632)
+
+### Fixed
+ * Fixed a bug where `seq`ing co-recursive lazy sequences would cause a stack overflow (#632)
+ * Fixed a spurious failure in the test runner and switched to using macro forms for test line numbers (#631)
 
 ### Removed
  * Removed Click as a dependency in favor of builtin `argparse` (#622, #624)

src/basilisp/core.lpy

@@ -1,5 +1,23 @@
 (in-ns 'basilisp.core)
 
+(import* abc
+         atexit
+         collections
+         decimal
+         fractions
+         functools
+         multiprocessing
+         os
+         pathlib
+         [queue :as py-queue]
+         random
+         re
+         threading
+         [time :as py-time]
+         uuid)
+
+(import* attr)
+
 (def ^{:doc      "Create a list from the arguments."
        :arglists '([& args])}
   list
@@ -928,8 +946,6 @@
 ;; Futures ;;
 ;;;;;;;;;;;;;
 
-(import* atexit)
-
 (def ^:dynamic *executor-pool*
   (basilisp.lang.futures/ThreadPoolExecutor))
 
@@ -1103,8 +1119,6 @@
 ;; Simple Predicates ;;
 ;;;;;;;;;;;;;;;;;;;;;;;
 
-(import* decimal fractions uuid)
-
 (defn any?
   "Return true for any x."
   [_]
@@ -1404,6 +1418,24 @@
 ;; Type Coercion ;;
 ;;;;;;;;;;;;;;;;;;;
 
+(defn cast
+  "Throws a `TypeError` if x is not a cls. Otherwise, return x."
+  [cls x]
+  (when-not (instance? cls x)
+    (throw (python/TypeError
+            (str "Cannot cast object of type " (python/type x) " to " cls))))
+  x)
+
+(defn class
+  "Return the class of x."
+  [x]
+  (python/type x))
+
+(defn type
+  "Return the type of x."
+  [x]
+  (python/type x))
+
 (defn bigdec
   "Coerce x to a Decimal."
   [x]
@@ -3134,8 +3166,6 @@
                         (mapcat walk (children node))))))]
     (walk root)))
 
-(import* multiprocessing)
-
 (def ^:dynamic *pmap-cpu-count*
   (* 2 (multiprocessing/cpu-count)))
 
@@ -3190,8 +3220,6 @@
 ;; Random Functions ;;
 ;;;;;;;;;;;;;;;;;;;;;;
 
-(import* random)
-
 (defn rand
   "Return a random real number between lower (default: 0) and upper (default: 1) inclusive."
   ([] (random/uniform 0 1))
@@ -3627,8 +3655,6 @@
        (finally
          (pop-thread-bindings)))))
 
-(import* [time :as py-time])
-
 (defn ^:private perf-counter
   []
   (py-time/perf-counter))
@@ -3750,8 +3776,6 @@
 ;; String Functions ;;
 ;;;;;;;;;;;;;;;;;;;;;;
 
-(import* os)
-
 (defn format
   "Format a string as by Python's `%` operator."
   [fmt & args]
@@ -3781,8 +3805,6 @@
 ;; File Functions ;;
 ;;;;;;;;;;;;;;;;;;;;
 
-(import* pathlib)
-
 (defn file-seq
   "Return a seq of `pathlib.Path` objects for all files and subdirectories of `dir`."
   [dir]
@@ -4520,8 +4542,6 @@
 ;; Regex Functions ;;
 ;;;;;;;;;;;;;;;;;;;;;
 
-(import re)
-
 (defn re-pattern
   "Return a new re.Pattern instance."
   [s]
@@ -4577,7 +4597,7 @@
 ;; Multimethods ;;
 ;;;;;;;;;;;;;;;;;;
 
-(import basilisp.lang.multifn)
+(import* basilisp.lang.multifn)
 
 (defmacro defmulti
   "Define a new multimethod with the dispatch function."
@@ -5034,8 +5054,6 @@
 ;; Interfaces ;;
 ;;;;;;;;;;;;;;;;
 
-(import* abc)
-
 (defmulti munge
   "Munge the input value into a Python-safe string. Converts keywords and
   symbols into strings as by `name` prior to munging. Returns a string."
@@ -5174,8 +5192,6 @@
 ;; Protocols ;;
 ;;;;;;;;;;;;;;;
 
-(import* functools)
-
 (defn ^:private gen-protocol-dispatch
   "Return the dispatch function for a single protocol method."
   [protocol-name interface-name [method-name & args+docstring :as method-def]]
@@ -5656,8 +5672,6 @@
 ;; Records ;;
 ;;;;;;;;;;;;;
 
-(import* attr)
-
 (defn record?
   "Return true if v is a record type."
   [v]
@@ -5937,8 +5951,6 @@
 ;; Transducers ;;
 ;;;;;;;;;;;;;;;;;
 
-(import* collections)
-
 ;; Eduction types return a custom iterator type which continually pulls from the
 ;; input collection (cast as a `seq`). `xf` is called on each value of that
 ;; sequence and it stores eligible values in a queue (`buf`). `__next__` adds
@@ -6125,3 +6137,90 @@
     ([result] (rf result))
     ([result input]
      (reduce rf result input))))
+
+;;;;;;;;;;
+;; Taps ;;
+;;;;;;;;;;
+
+(defonce ^:private tap-queue
+  (->> (os/getenv "BASILISP_TAP_QUEUE_SIZE" 1024)
+       (python/int)
+       (py-queue/Queue)))
+
+(defonce ^:private tapset (atom {}))
+
+(defonce ^:private tap-thread
+  (delay
+   (doto (threading/Thread
+          **
+          :target (fn []
+                    (loop []
+                      (let [{:keys [topic val]} (.get tap-queue)
+                            topic-tapset        (get @tapset topic #{})]
+                        (doseq [tap (seq topic-tapset)]
+                          (try
+                            (tap val)
+                            (catch python/Exception _ nil)))
+                        (.task-done tap-queue))
+                      (recur)))
+          :daemon true)
+     (.start))))
+
+(defn add-tap
+  "Add `tf`, a function of one argument, to the tap set for the topic `topic`. If no
+  topic is given, the default topic is used.
+
+  Tap functions are called only with values from calls to `tap>` with the topic they
+  are added with.
+
+  Taps may be removed from the tap set for a topic (or with the default topic) by a
+  matching call to `remove-tap`. Taps are identified only by their identity, so hang
+  on to a reference if you do need to remove the tap.
+
+  Returns `nil`."
+  ([tf]
+   (add-tap :basilisp.core.tap/default tf))
+  ([topic tf]
+   (force tap-thread)
+   (swap! tapset
+          (fn [old-state]
+            (let [topic-tapset (get old-state topic #{})]
+              (->> (conj topic-tapset tf)
+                   (assoc old-state topic)))))
+   nil))
+
+(defn remove-tap
+  "Remove a tap function from the tap set added by `add-tap`.
+
+  Tap functions may only be removed from the tap set corresponding to the topic they
+  were added with. If no topic is given, the default topic is used.
+
+  Returns `nil` in all cases."
+  ([tf]
+   (remove-tap :basilisp.core.tap/default tf))
+  ([topic tf]
+   (force tap-thread)
+   (swap! tapset
+          (fn [old-state]
+            (let [topic-tapset (get old-state topic #{})]
+              (->> (disj topic-tapset tf)
+                   (assoc old-state topic)))))
+   nil))
+
+(defn tap>
+  "Send the value `val` to all tap functions registered for the topic. If no topic
+  is given, the default topic is used.
+
+  `tap>` will never block, though if the tap queue is full then tap values may be
+  dropped.
+
+  Returns true if `val` was sent to the queue, `false` if `val` was dropped."
+  ([val]
+   (tap> :basilisp.core.tap/default val))
+  ([topic val]
+   (force tap-thread)
+   (try
+     (do
+       (.put-nowait tap-queue {:topic topic :val val})
+       true)
+     (catch queue/Full _ false))))

src/basilisp/test.lpy

@@ -1,6 +1,4 @@
 (ns basilisp.test
-  (:import
-   inspect)
   (:require
    [basilisp.template :as template]))
 
@@ -11,24 +9,14 @@
 (def ^:dynamic *test-section* nil)
 (def ^:dynamic *test-failures* nil)
 
-(defn line-no
-  "Get the line number from the current interpreter stack.
-
-  This is a horrible hack and it requires each particular assertion case
-  to define their frame offset from here, but it seems to be the most
-  accessible way of determining the line number without capturing it
-  for every test (including non-failing tests)."
-  [n]
-  (.-lineno (nth (inspect/stack) n)))
-
 (defmulti gen-assert
-  (fn [expr _]
+  (fn [expr _ _]
     (cond
       (list? expr) (first expr)
       :else        :default)))
 
 (defmethod gen-assert '=
-  [expr msg]
+  [expr msg line-num]
   `(when-not ~expr
     (swap! *test-failures*
            conj
@@ -38,11 +26,11 @@
             :expr         (quote ~expr)
             :actual       ~(nth expr 2)
             :expected     ~(second expr)
-            :line         (line-no 1)
+            :line         ~line-num
             :type         :failure})))
 
 (defmethod gen-assert 'thrown?
-  [expr msg]
+  [expr msg line-num]
   (let [exc-type (second expr)
         body     (nthnext expr 2)]
     `(try
@@ -55,7 +43,7 @@
                  :expr         (quote ~expr)
                  :actual       result#
                  :expected     (quote ~exc-type)
-                 :line         (line-no 1)
+                 :line         ~line-num
                  :type         :failure}))
        (catch ~exc-type _ nil)
        (catch python/Exception e#
@@ -67,11 +55,11 @@
                  :expr         (quote ~expr)
                  :actual       e#
                  :expected     ~exc-type
-                 :line         (line-no 1)
+                 :line         ~line-num
                  :type         :failure})))))
 
 (defmethod gen-assert :default
-  [expr msg]
+  [expr msg line-num]
   `(let [computed# ~expr]
      (when-not computed#
        (swap! *test-failures*
@@ -82,27 +70,28 @@
                :expr         (quote ~expr)
                :actual       computed#
                :expected     computed#
-               :line         (line-no 1)
+               :line         ~line-num
                :type         :failure}))))
 
 (defmacro is
   "Assert that expr is true. Must appear inside of a deftest form."
   ([expr]
    `(is ~expr (str "Test failure: " (pr-str (quote ~expr)))))
   ([expr msg]
-   `(try
-      ~(gen-assert expr msg)
-      (catch python/Exception e#
-        (swap! *test-failures*
-               conj
-               {:test-name    *test-name*
-                :test-section *test-section*
-                :message      (str "Unexpected exception thrown during test run: " (python/repr e#))
-                :expr         (quote ~expr)
-                :actual       e#
-                :expected     (quote ~expr)
-                :line         (line-no 1)
-                :type         :error})))))
+   (let [line-num (:basilisp.lang.reader/line (meta &form))]
+     `(try
+        ~(gen-assert expr msg line-num)
+        (catch python/Exception e#
+          (swap! *test-failures*
+                 conj
+                 {:test-name    *test-name*
+                  :test-section *test-section*
+                  :message      (str "Unexpected exception thrown during test run: " (python/repr e#))
+                  :expr         (quote ~expr)
+                  :actual       e#
+                  :expected     (quote ~expr)
+                  :line         ~line-num
+                  :type         :error}))))))
 
 (defmacro are
   "Assert that expr is true. Must appear inside of a deftest form."