 
   (def parse-forms
     (domonad [forms (none-or-more parse-single-form)]
+      ; We really want to evaluate the forms top to bottom. Without the lazy sequence,
+      ; evaluation would be bottom to top. It would not matter, except for the 
+      ; issue of JavaScript library and stylesheet injection, which implies as specific
+      ; ordering. Perhaps there's a solution related to monads, as a way of dealing with
+      ; the ordering issues without the expense of lazy evaluation (and forcing the entire
+      ; DOM tree to be realized).
       `(lazy-seq (combine ~@forms))))
 ) ; with-monad parser-m
 


  ; Accept a single form that will act as a renderer, returning a render
  ; result, which will be combined with other render results via the
  ; parse-forms parser.
  (def parse-form
       (domonad [form match-form]
         form))


(defn convert-render-result
  [any]
  "Checks the result of invoking a rendering function (or evaluating a symbol), to ensure that only
   acceptible values are returned."
  (cond
    ; A map is assumed to be a DOM node
    (map? any) (if (:cascade-dom-node ^any) any (fail "Not a DOM node: %s" (ppstring any)))
    (string? any) (text-node any)
    (number? any) (raw-node (str any))
    true (throw (RuntimeException.
      (format "A rendering function returned %s. Rendering functions should return nil, a string, a seq of DOM nodes, or a single DOM node."
    (pr-str any))))))
