tree.clj

(ns tree
  (:require [clojure.contrib.string :as str]
            [clojure.contrib.io :as io]))

(def lines (rest (io/read-lines "/Users/paul/Work/pes500k.csv")))
(def postcodes-from-file (map (fn [x] (let [parts (str/split #"," x)
                                           postcode (str/replace-str " "
                                                                     ""
                                                                     (first parts))
                                           region-id (first (rest parts))]
                                       {:postcode postcode
                                        :region-id region-id}))
                              lines))

(def postcodes '({:postcode "AB6" :region-id 9}
                 {:postcode "AL" :region-id 10}
                 {:postcode "AB" :region-id 12}
                 {:postcode "AL4" :region-id 10}
                 {:postcode "AL5" :region-id 9}))

(defn next-record
  [record]
  {:postcode (apply str (rest (:postcode record)))
   :region-id (:region-id record)})

(defn record-to-tree
  ([record] (record-to-tree record {}))
  ([record tree]
     (let [postcode (:postcode record)
           region-id (:region-id record)]
       (if (nil? (seq postcode))
         tree
         (assoc tree
           (keyword (str (first postcode)))
           (record-to-tree (next-record record)
                           {:region-id region-id}))))))

(defn merge-tree
  [tree subtree]
  (if (not (map? subtree))
    tree
    (let [first-key (first (keys subtree))]
      (if (contains? tree first-key)
        (assoc tree first-key (merge-tree (first-key tree)
                                          (first-key subtree)))
        (assoc tree first-key (first-key subtree))))))

;; tree=> (merge-tree {:a {:b 2}} {:a {:c 3}})
;; {:a {:c 3, :b 2}}

;; tree=> (reduce merge-tree {} (map record-to-tree postcodes))
;; {:A {:B {:region-id 12}, :L {:4 {:region-id 10}, :region-id 10},
;; :region-id 10}}

(println "Loading results")

(def results (reduce merge-tree {} (map record-to-tree postcodes-from-file)))

(println "Results loaded")

(defn lookup-postcode
  [results postcode]
  (if (nil? (seq postcode))
    (:region-id results)
    (recur ((keyword (str (first postcode))) results)
           (rest postcode))))

;; tree=> (lookup-postcode results "AB")
;; 12

;; (println results)
(println (str "Region for B68 8QQ: "
              (lookup-postcode results "B688QQ")))

(println (str "Region for AL4 9HA: "
              (lookup-postcode results "AL49HA")))