   "Internally, re-frame uses the logging functions: `warn`, `log`, `error`, `group` and `groupEnd`
 
    By default, these functions map directly to the default `js/console` implementations,
-   but you can override with your own fns (set or subset).
-   
-   `new-loggers` should be a map with the same keys as `loggers` 
+   but you can override with your own fns (set or subset) if you wish to handle the logging yourself.
+   
+   `new-loggers` should be a map with the same keys as standard `loggers` 
 
    Example Usage:
    ```clj

(def on-changes
  "An interceptor factory, which is to say, a function which will return an interceptor. 
   
   The returned interceptor will observe N paths within `db`, and if any of them
   test not identical? to their previous value  (as a result of a event handler
   being run), then it runs `f` to compute a new value, which is then assoc-ed
   into the given `out-path` within `db`.

   Example Usage:

   ```clj
      (defn my-f
        [a-val b-val]
        ... some computation on a and b in here)

      (reg-event-db 
        :event-id 
        [(on-changes my-f [:c]  [:a] [:b]) ... other interceptors]  <-- used here
        (fn [db v]
           ...))
    ```
   
    Put this Interceptor on the right handlers (ones which might change :a or :b)
    and it will: 
   
     - call `f` each time the value at path [:a] or [:b] changes

   (interceptor/get-effect context key not-found)))

(defn assoc-effect
   "A utility function, typically used when writing an interceptor's `:after `function. 
   
   Adds or updates a key/value pair in the `:effects` map within `context`. "
  [context key value]
  (interceptor/assoc-effect context key value))

(defn enqueue
  "An advanced utility function, typically used when writing an interceptor's `:before `function. 
  
  Adds a collection of `interceptors` to the end of `context's` execution `:queue`, and then
  returns the updated `context`."
