Add several new namespace functions (#405)

* Add several new namespace functions

* Use a threading.local object rather than an Atom

* Small binding macro test

* Fix some tests

* Tests

* Remove unused type ignore comments for updated MyPy

* Undo that

* Add additional test case

* Use 3.6 base for now

* Remove useless returns

* Fix error in Test run

* Throw RTE for pop-without-corresponding-push

* Additional runtime coverage

* lol

Author: chrisrink10

src/basilisp/core.lpy

@@ -1813,6 +1813,24 @@
                       (str n ".")))]
       `(~s ~@args))))
 
+(defn push-thread-bindings
+  "Takes a map of Var/value pairs and applies the given value to the Var in the
+  current thread.
+
+  This call should be accompanied with a pop-thread-bindings call in a
+  try/finally block.
+
+  This function is a very low level function and its use is discouraged in favor
+  of a higher level construct like the binding macros."
+  [bindings]
+  (basilisp.lang.runtime/push-thread-bindings bindings))
+
+(defn pop-thread-bindings
+  "Pop thread bindings set by a corresponding call to push-thread-bindings. This
+  should not be called without a prior call to push-thread-bindings."
+  []
+  (basilisp.lang.runtime/pop-thread-bindings))
+
 (defmacro binding
   "Establish thread-local bindings for the vars given. The bindings are guaranteed
   to clear once execution passes outside the scope of this block."
@@ -1823,18 +1841,18 @@
     (throw
      (ex-info "Expected an even number of bindings"
               {:bindings bindings})))
-  (let [vvar (first bindings)
-        val  (second bindings)]
+  (let [var-bindings (reduce (fn [v pair]
+                               (let [vvar (first pair)
+                                     vval (second pair)]
+                                 (conj v `(var ~vvar) vval)))
+                             []
+                             (partition 2 bindings))]
     `(try
        (do
-         (. (var ~vvar) (~'push-bindings ~val))
-         ~@(if (nthnext bindings 2)
-             [(concat
-               (list 'binding (vec (nthrest bindings 2)))
-               body)]
-             body))
+         (push-thread-bindings (hash-map ~@var-bindings))
+         ~@body)
        (finally
-         (. (var ~vvar) ~'pop-bindings)))))
+         (pop-thread-bindings)))))
 
 (import* [time :as py-time])
 
@@ -2194,10 +2212,61 @@
                                                   ctx
                                                   module)))
 
+;;;;;;;;;;;;;;;;;;;
+;; Var Utilities ;;
+;;;;;;;;;;;;;;;;;;;
+
+(defn alter-var-root
+  "Atomically alter the Var root by calling (apply f root args) and setting
+  the root as the result."
+  [v f & args]
+  (apply-method v alter-root f args))
+
+(defn find-var
+  "Return the Var named by namespace-qualified sym if it exists, or nil otherwise."
+  [sym]
+  (basilisp.lang.runtime.Var/find sym))
+
+(defn thread-bound?
+  "Return true if vars are thread-bound, which implies that a set! will succeed.
+  Returns true if no vars are given."
+  [& vars]
+  (loop [v (first vars)
+         r (rest vars)]
+    (if-not v
+      true
+      (if (.-is-thread-bound v)
+        (recur (first r) (rest r))
+        false))))
+
+(defn var-get
+  "Return the value inside the Var. Return thread local bindings if they exist,
+  otherwise, return the root binding."
+  [v]
+  @v)
+
+(defn var-set
+  "Set the binding of the Var. Must be thread-local."
+  [v val]
+  (if (thread-bound? v)
+    (set! (.-value v) val)
+    (throw
+     (ex-info "Cannot set non-thread-bound Var binding" {:var v}))))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Namespace Utilities ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;
 
+(defn all-ns
+  "Return a sequence of all namespaces."
+  []
+  (vals @basilisp.lang.runtime.Namespace/-NAMESPACES))
+
+(defn find-ns
+  "Return the namespace named by sym if it exists, or nil otherwise."
+  [sym]
+  (basilisp.lang.runtime.Namespace/get sym))
+
 (defn the-ns
   "If v is a symbol, return the Namespace named by that symbol if it
   exists. If v is a Namespace, return it. Otherwise, throw an exception."
@@ -2215,11 +2284,35 @@
               {:value v
                :type  (python/type v)}))))
 
+(defn intern
+  "Finds or creates a Var in ns (which is either a namespace or symbol),
+  setting the root binding to val, if provided. The namespace must exist.
+  Return the Var."
+  ([ns name]
+   (let [ns (the-ns ns)
+         v  (basilisp.lang.runtime/Var ns name)]
+     (.intern ns v)))
+  ([ns name val]
+   (let [ns (the-ns ns)
+         v  (basilisp.lang.runtime/Var ns name)]
+     (set! (.-root v) val)
+     (.intern ns v))))
+
 (defn create-ns
   "Create a Namespace with the name ns-sym or return the existing one
   if it already exists."
   [ns-sym]
-  (.get-or-create basilisp.lang.runtime/Namespace ns-sym))
+  (basilisp.lang.runtime.Namespace/get-or-create ns-sym))
+
+(defn remove-ns
+  "Remove the namespace named by the symbol."
+  [ns-sym]
+  (basilisp.lang.runtime.Namespace/remove ns-sym))
+
+(defn ns-name
+  "Return the name of the namespace, a symbol."
+  [ns]
+  (.-name ns))
 
 (defn ns-aliases
   "Return a map of Basilisp namespaces which are aliased in the current
@@ -2232,27 +2325,37 @@
                 m
                 (assoc m alias namespace))))
           {}
-          (.-aliases ns)))
+          (.-aliases (the-ns ns))))
 
 (defn ns-imports
   "Return a set of Python modules which are imported in the current
   namespace."
   [ns]
-  (.-imports ns))
+  (.-imports (the-ns ns)))
 
 (defn ns-interns
   "Return a map of symbols to Vars which are interned in the current
   namespace."
   [ns]
-  (.-interns ns))
+  (.-interns (the-ns ns)))
+
+(defn ns-unalias
+  "Remove the alias for the symbol sym from ns. Return nil."
+  [ns sym]
+  (.remove-alias (the-ns ns) sym))
+
+(defn ns-unmap
+  "Remove the mapping for the symbol sym from ns. Return nil."
+  [ns sym]
+  (.unmap (the-ns ns) sym))
 
 (defn ns-publics
   "Return a map of symbols to public Vars which are interned in the
   current namespace.
 
   Public vars are Vars which are declared without :private metadata."
   [ns]
-  (let [interns (ns-interns ns)]
+  (let [interns (ns-interns (the-ns ns))]
     (if-not (seq interns)
       {}
       (reduce (fn [m entry]
@@ -2266,22 +2369,23 @@
   "Return a map of symbols to Vars which are referred in the current
   namespace."
   [ns]
-  (.-refers ns))
+  (.-refers (the-ns ns)))
 
 (defn ns-map
   "Return a map of all the mapped symbols in the namespace.
 
   Includes the return values of ns-interns and ns-refers in one map."
   ([] (ns-map *ns*))
   ([ns]
-   (merge
-    (ns-interns ns)
-    (ns-refers ns))))
+   (let [resolved-ns (the-ns ns)]
+     (merge
+      (ns-interns resolved-ns)
+      (ns-refers resolved-ns)))))
 
 (defn ns-resolve
   "Return the Var which will be resolved by the symbol in the given namespace."
   [ns sym]
-  (basilisp.lang.runtime/resolve-var sym ns))
+  (basilisp.lang.runtime/resolve-var sym (the-ns ns)))
 
 (defn resolve
   "Return the Var which will be resolved by the symbol in the namespace currently
@@ -2339,6 +2443,14 @@
                            (recur (rest refers)))))]
         (do-refer interns)))))
 
+(def refer-basilisp
+  "Refer Vars from basilisp.core using the same filter syntax as refer."
+  (partial refer 'basilisp.core))
+
+(def refer-clojure
+  "Compatibility layer with JVM Clojure, which points to refer-basilisp."
+  refer-basilisp)
+
 (import importlib)
 
 (defn ^:private add-refers
@@ -3333,3 +3445,4 @@
          ((.- ~type-name ~'create) m#))
 
        ~type-name)))
+

src/basilisp/importer.py

@@ -40,7 +40,7 @@ def _basilisp_bytecode(
     data = bytearray(MAGIC_NUMBER)
     data.extend(_w_long(mtime))
     data.extend(_w_long(source_size))
-    data.extend(marshal.dumps(code))  # type: ignore
+    data.extend(marshal.dumps(code))
     return data
 
 
@@ -77,7 +77,7 @@ def _get_basilisp_bytecode(
         logger.debug(message)
         raise ImportError(message, **exc_details)  # type: ignore
 
-    return marshal.loads(cache_data[12:])  # type: ignore
+    return marshal.loads(cache_data[12:])
 
 
 def _cache_from_source(path: str) -> str:

src/basilisp/lang/interfaces.py

@@ -141,15 +141,7 @@ def disj(self, *elems: T) -> "IPersistentSet[T]":
         raise NotImplementedError()
 
 
-# MyPy has a lot of trouble dealing with the fact that Vectors are
-# considered as mapping types (from int -> T) and more traditional
-# sequential collections since the Python supertypes signatures conflict.
-# Below, we override the supertype signatures to select the signature
-# we specifically want to appear, but MyPy still complains. For now,
-# we will simply silence MyPy.
-class IPersistentVector(  # type: ignore
-    Sequence[T], IAssociative[int, T], IPersistentStack[T]
-):
+class IPersistentVector(Sequence[T], IAssociative[int, T], IPersistentStack[T]):
     __slots__ = ()
 
     @abstractmethod

src/basilisp/lang/list.py

@@ -10,7 +10,7 @@
 T = TypeVar("T")
 
 
-class List(IMeta, ISeq[T], IPersistentList[T]):  # type: ignore
+class List(IMeta, ISeq[T], IPersistentList[T]):
     """Basilisp List. Delegates internally to a pyrsistent.PList object.
 
     Do not instantiate directly. Instead use the l() and list() factory

src/basilisp/lang/map.py

@@ -19,7 +19,7 @@
 V = TypeVar("V")
 
 
-class MapEntry(IMapEntry[K, V], Vector[Union[K, V]]):  # type: ignore
+class MapEntry(IMapEntry[K, V], Vector[Union[K, V]]):
     __slots__ = ()
 
     def __init__(self, wrapped: "PVector[Union[K, V]]") -> None: