anchor.diff:      (setq elts (map-elements-reader stream))
       ;; TODO: implement opts for what type of object to return
       ;; NOTE: in the future, a functional immutable map will be the default
  -    `(apply #'alexandria:plist-hash-table (cons (list ,@elts) (list ,@opts)))))
  +    (case output-type
  +      (:hash-table `(apply #'alexandria:plist-hash-table (cons (list ,@elts) (list ,@opts))))
  +      (:alist `(plist->alist (list ,@elts)))
  +      (:plist `(list ,@elts)))))
   
   ;; TODO: make this enableable
   (set-dispatch-macro-character #\# #\M #'map-literal-reader)
  
positive.code:   ; or a { in which case we want to read the elements
    (let ((opts nil)
          (elts nil)
          (next-char (peek-char nil stream)))
      (when (eq next-char #\()
        (setq opts (read stream t nil t)))
      ;; set up some default opts
      (unless (member :test opts)
        (setq opts (cons :test (cons '(function equal) opts))))
      ;; TODO: this is going to be inefficient-- accumulating elements into a
      ;; list, then reaccumulating them into whatever output structure was
      ;; requested.  Pass a flag so that we can construct the correct
  
negative.code: (defpackage :cjf-stdlib
    (:use :cl :split-sequence)
    (:export :mget :mget* :println :-> :->string :keys :ht :plist->alist :hset
     :slurp :alist->ht :<- :mset! :remove-from-plist :mset :<> :tee :rmapcar :tap
     ; re-export from split-sequence
     :split-sequence :split-sequence-if :split-sequence-if-not
     ))
  