 (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
+   Returns an interceptor which 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
+```clj
       (defn my-f
         [a-val b-val]
         ... some computation on a and b in here)
+   
+      ;; use it
+      (def my-interceptor (on-changes my-f [:c]  [:a] [:b]))
 
       (reg-event-db 
         :event-id 
-        [(on-changes my-f [:c]  [:a] [:b]) ... other interceptors]  <-- used here
+        [... my-interceptor ...]  ;; <-- ultimately used here
         (fn [db v]
            ...))
-    ```
-   
-    Put this Interceptor on the right handlers (ones which might change :a or :b)
+```
+   
+    Put this Interceptor on handlers which might change paths :a or :b
     and it will: 
    
      - call `f` each time the value at path [:a] or [:b] changes

   Accepts three optional, named arguments:
   
     - `:id` - an id for the interceptor (decorative only)
     - `:before` - the before function 
     - `:after`  - the after function 
   
   Example use:
   ```clj
   (def my-interceptor
     (->interceptor                
       :id     :my-interceptor       

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

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