                 results)
             (rf results (impl/mappify-row @hdr input)))))))))
 
+;; Here's an example using the mappify transducers.
+;;
+;;     => (with-open [in-file (io/reader "test/test.csv")]
+;;          (transduce
+;;            (mappify)
+;;            conj
+;;            []
+;;            (csv/parse-csv in-file))
+;;
+;;     [{:this "# some comment lines..."}
+;;      {:this "1", :that "2", :more "stuff"}
+;;      {:this "2", :that "3", :more "other yeah"}]
+;;
+;; <br/>
+;;
+;; Note that `"# some comment lines..."` was really intended to be left out as a comment.
+;; We can address this with the following function:
+
+
+;; <br/>
+;; ## structify
+
 (defn structify
   "Takes a sequence of row vectors, as commonly produced by csv parsing libraries, and returns a sequence of
   structs. By default, the first row vector will be interpreted as a header, and used as the keys for the maps.
   However, this and other behaviour are customizable via an optional `opts` map with the following options:
- 
+
   * `:keyify` - bool; specify whether header/column names should be turned into keywords (default: `true`).
   * `:header` - specify the header to use for map keys, preventing first row of data from being consumed as header."
   ([] (structify {}))

            (if (and x (commented? x))
              results
              (rf results input)))))))))

(defn cast-with
  "Casts the vals of each row according to `cast-fns`, which must either be a map of

              (do (vreset! fst input) (rf results input))) ;; fst is nil. reset fst and return the results.
            (rf results (impl/cast-row cast-fns input :only only :exception-handler exception-handler)))))))))

;; Let's try casting a numeric column using this function:
;;
;;     => (with-open [in-file (io/reader "test/test.csv")]
;;          (transduce
;;            (comp
;;              (remove-comments)
;;              (mappify)
;;              (cast-with {:this #(Integer/parseInt %)}))
;;            conj
;;            []
;;            (csv/parse-csv in-file)))
;;
;;     ({:this 1, :that "2", :more "stuff"}
;;      {:this 2, :that "3", :more "other yeah"})
;;
;; Alternatively, if we want to cast multiple columns using a single function, we can do so
;; by passing a single casting function as the first argument.
;;
;;     => (with-open [in-file (io/reader "test/test.csv")]
;;          (transduce
;;            (comp
;;              (remove-comments)
;;              (mappify)
;;              (cast-with #(Integer/parseInt %) {:only [:this :that]}))
;;            conj
;;            []
;;            (csv/parse-csv in-file)))
;;
;;     ({:this 1, :that 2, :more "stuff"}
;;      {:this 2, :that 3, :more "other yeah"})
;;
;; Note that this function handles either map or vector rows.
;; In particular, if you’ve imported data without consuming a header (by either not using mappify or
;; by passing `:header false` to `process` or `slurp-csv` below), then the columns can be keyed by their
;; zero-based index.
;; For instance, `(cast-with {0 #(Integer/parseInt %) 1 #(Double/parseDouble %)} rows)`
;; will parse the first column as integers and the second as doubles.
;;
;; <br/>
;; It's worth pointing out this function isn't strictly an _input_ processing function, but could be
;; used for intermediate or output preparation processing.


;; <br/>
;; ## process

(defn process
  "This function wraps together the most frequently used input processing capabilities,
