Update name of <!-no-throw to just <!

Author: tanzoniteblack

docs/deferred.md

@@ -166,14 +166,14 @@ In this example, `c` is declared within a normal `let` binding, and as such we c
 
 It can be helpful to think of `let-flow` as similar to Prismatic's [Graph](https://github.com/prismatic/plumbing#graph-the-functional-swiss-army-knife) library, except that the dependencies between values are inferred from the code, rather than explicitly specified.  Comparisons to core.async's goroutines are less accurate, since `let-flow` allows for concurrent execution of independent paths within the bindings, whereas operations within a goroutine are inherently sequential.
 
-### manifold.tsasvla
+### manifold.go-off
 
-An alternate way to write code using deferreds is the macro `manifold.tsasvla/tsasvla`. This macro is an almost exact mirror of the `go` macro from [clojure/core.async](https://github.com/clojure/core.async), to the point where it actually utilizes the state machine functionality from core.async. In order to use this macro, `core.async` must be a dependency provided by the user. The main difference between `go` and `tsasvla`, besides tsasvla working with deferrables instead of core.async channels, is the `take` function being `<!?` instead of `<!`. The difference in function names is used to indicate exceptions behave the same as a non-async clojure block (i.e. are thrown) instead of silently swallowed & returning `nil`.  
+An alternate way to write code using deferreds is the macro `manifold.go-off/go-off`. This macro is an almost exact mirror of the `go` macro from [clojure/core.async](https://github.com/clojure/core.async), to the point where it actually utilizes the state machine functionality from core.async. In order to use this macro, `core.async` must be a dependency provided by the user. The main difference between `go` and `go-off`, besides go-off working with deferrables instead of core.async channels, is the `take` function being `<!?` instead of `<!`. The difference in function names is used to indicate exceptions behave the same as a non-async clojure block (i.e. are thrown) instead of silently swallowed & returning `nil`.  
 
 The benefit of this macro over `let-flow` is that it gives complete control of when deferreds should be realized to the user of the macro, removing any potential surprises (especially around timeouts).
 
 ```clj
-@(tsasvla (+ (<!? (d/future 10))
+@(go-off (+ (<!? (d/future 10))
              (<!? (d/future 20))))                          ;; ==> 30
 ```
 
@@ -182,7 +182,7 @@ The benefit of this macro over `let-flow` is that it gives complete control of w
                          (catch Exception e
                            "ERROR"))))                      ; ==> nil
 
-@(tsasvla (try (<!? (d/future (/ 5 0)))
+@(go-off (try (<!? (d/future (/ 5 0)))
                (catch Exception e
                  "ERROR")))                                 ; ==> "ERROR"
 ```

src/manifold/go_off.clj

@@ -15,7 +15,7 @@
     (d/success! d value)
     d))
 
-(defn <!-no-throw
+(defn <!
   "takes value from deferred. Must be called inside a (go ...) block. Will
   return nil if closed. Will park if nothing is available. If an error
   is thrown inside the body, that error will be placed as the return value.
@@ -30,7 +30,7 @@
   Will park if nothing is available. If value that is returned is
   a Throwable, will re-throw."
   [port]
-  `(let [r# (<!-no-throw ~port)]
+  `(let [r# (<! ~port)]
      (if (instance? Throwable r#)
        ;; this is a re-throw of the original throwable. the expectation is that
        ;; it still will maintain the original stack trace
@@ -69,8 +69,8 @@
               nil))))))
 
 (def async-custom-terminators
-  {'manifold.go-off/<!-no-throw `manifold.go-off/take!
-   :Return                      `return-deferred})
+  {'manifold.go-off/<! `manifold.go-off/take!
+   :Return             `return-deferred})
 
 (defmacro go-off-executor
   "Implementation of go-off that allows specifying executor. See docstring of go-off for usage."
@@ -94,7 +94,7 @@
 (defmacro go-off
   "Asynchronously executes the body on manifold's default executor, returning
   immediately to the calling thread. Additionally, any visible calls to <!?
-  and <!-no-throw deferred operations within the body will block (if necessary)
+  and <! deferred operations within the body will block (if necessary)
   by 'parking' the calling thread rather than tying up an OS thread.
   Upon completion of the operation, the body will be resumed.