Ok I figured out why it returned every category mapping - it's because map returned a sequence and inside was true or false. So calling first on it made it work. But it still feels ugly...

(defn rule-matches-bank-line? [bank-line]
  (fn [mapping]
    (let [match-on-rules (:match-on mapping)]
      (->> (reduce #(keys %2) #{} match-on-rules)
           (map #(= (%1 %2) (bank-line %2)) match-on-rules)
           (first)))))

(defn categorise-bank-line [mappings bank-line]
  (filter (rule-matches-bank-line? bank-line) mappings))

the problem is not fully specified, match-on is an array of maps, are you supposed to match if at least one map satisfies the line ?

like [{"Payee" "Sharesies NZ"} {"Payee" "WGTN CITY COUNCIL"}] would match both lines ?

also, can the map contains multiple props ? and in that case i assume you need to match every values if i go with those assumptions:

(defn match-props? [bank-line props] (= (select-keys bank-line (keys props)) props))

(defn match-rule? [bank-line rule]
  (some (fn [props] (match-props? bank-line props)) (:match-on rule)))

try to divide the problem and name things if you're stuck like that, it's easier to debug simple functions in the repl

note that if your maps always have a single entry, it's easier to represent them with a pair

So just for fun I was thinking that this is a nice pattern matching exercise. The matcher is a macro though, so no dynamically created rules. But it's more flexible with the rules than any simple lookup can be... So if we accept the cost of rewriting the rules, you can get something like this :

(ns hayden-match
  (:require [clojure.data.csv :as csv]
            [ :as io]
            [clojure.string :as str]
            [clojure.core.match :refer [match]]))


(defn csv-data->maps [csv-data]
  (map zipmap
       (->> (first csv-data) ;; First row is the header
            (map keyword) ;; Drop if you want string keys instead
            repeat)
       (rest csv-data)))

(def data
  (with-open [reader (io/reader "src/haydendata.csv")]
    (-> (doall (csv/read-csv reader))
        csv-data->maps)))

(defn rate-category [m]
  (assoc m :category :Rates :type :expense))
(defn invest-category [m]
  (assoc m :category :Investing :type :expense))
(defn test-category [m]
  (assoc m :category :Testing :type :goblin))

(defn rule-matcher [entry]
  (match [entry]
    [{:Payee "WGTN CITY COUNCIL"}] (rate-category entry)
    [{:Payee "Sharesies NZ"}] (invest-category entry)
    [{:Payee "WGTN CITY COUNCIL"}] (invest-category entry)
    [{:Payee "Top bidder"}] (test-category entry)
    [{:Payee "Microinc"}] (test-category entry)
    :else (assoc entry ::failure "failed to parse..")))


(defn get-month 
  "seriously bad date getter. will bite! not house trained!"
  [date]
  (-> (str/split date #"/")
      second
      Integer/parseInt))

(defn totals [grpd-data]
  (reduce (fn [m [[month category] transactions]] ;; needs additional group by year
            (conj m
                  {:month month
                   :category category
                   :total-expenses (->> (filter #(= :expense (:type %)) transactions)
                                        (map :Amount)
                                        (map #(Float/parseFloat %))
                                        (reduce +))
                   :total-income (->> (filter #(= :income (:type %)) transactions)
                                      (map :Amount)
                                      (map #(Float/parseFloat %))
                                      (reduce +))
                   :transactions transactions}))
          []
          grpd-data))


(defn parse-transactions [data]
  (-> (group-by (juxt #(get-month (:Date %))
                      #(:category %)) (map rule-matcher data)) ;; also group by here!
      totals))

(comment 
  (parse-transactions data)
  ;; => [{:month 1,
  ;;      :category :Investing,
  ;;      :total-expenses -10.0,
  ;;      :total-income 0,
  ;;      :transactions
  ;;      [{:category :Investing,
  ;;        :type :expense,
  ;;        :Payee "Sharesies NZ",
  ;;        :Memo "A/P AM623847",
  ;;        :Cheque Number "",
  ;;        :Date "2022/01/18",
  ;;        :Unique Id "2022011101",
  ;;        :Amount "-10.00",
  ;;        :Tran Type "A/P"}]}
  ;;     {:month 5,
  ;;      :category :Rates,
  ;;      :total-expenses -139.47,
  ;;      :total-income 0,
  ;;      :transactions
  ;;      [{:category :Rates,
  ;;        :type :expense,
  ;;        :Payee "WGTN CITY COUNCIL",
  ;;        :Memo "D/D WCC RATES 107655 19 MADEUPLANE",
  ;;        :Cheque Number "",
  ;;        :Date "2022/05/20",
  ;;        :Unique Id "2022012301",
  ;;        :Amount "-139.47",
  ;;        :Tran Type "D/D"}]}]

  
  )

Thank you both for the insights! Appreciate it. I'll rewrite what I've done both ways and see what I can learn from it

Hello! Calva can do that for you. And then some. https://calva.io/ We help each other in #calva

Thanks @U0ETXRFEW.

Thanks, @U064X3EF3.