Uncle Bob's arg parsing in Clojure

args.clj

(ns args)

(defn- parse-schema
  "Parse comma separated schema. Returns map of character to type keyword."
  [schema-spec]
  (into {}
        (map (fn [flag]
               (let [chr (.charAt flag 0)
                     spec (subs flag 1)]
                 [chr (case spec
                        "" :boolean
                        "#" :integer
                        "*" :string)])))
        (.split schema-spec ",")))

(defn- parse-arg
  "Parse a single argument string in the schema."
  [schema arg]
  (let [chr (.charAt arg 1)]
    (if-let [type (schema chr)]
      {chr (case (schema chr)
             :boolean true
             :integer (Integer/parseInt (subs arg 2))
             :string (subs arg 2))}
      (throw (Exception. (str "Unrecognized flag: " arg))))))

(defn args [schema-spec args-array]
  (let [schema (parse-schema schema-spec)]
    (reduce merge
            (into {}
                  (map (juxt first (constantly false)))
                  (filter (comp #(= :boolean %) second) schema))
            (map (partial parse-arg schema) args-array))))

;; Works like:
;; (args "l,p#,d*" (into-array String ["-p8080" "-dFoo" "-l"]))
;; => {\l true, \p 8080, \d "Foo"}
;;
;; (args "l,p#,d*" (into-array String ["-p8080" "-dFoo"]))
;; => {\l false, \p 8080, \d "Foo"}
;;
;; (args "l,p#,d*" (into-array String ["-p8080" "-dFoo" "-X"]))
;; Exception Unrecognized flag: -X