Progress on my BJ analyzer (with code)... and should I keep going?

 ;blackjack analyzer in Clojure by John Tollison, copyright 2013
(ns myproject.core)

(defmacro defn-memo [name & body] `(def ~name (memoize (fn ~body))))

(def deck1 [2 3 4 5 6 7 8 9 10 10 10 10 1]) ;infinite deck
(def combos (for [i deck1 j deck1] (vec (sort < [i j]))))

(defn doseqfor [deck fn1] ;dual pass for memoizing and averaging game trees, depth first; returns single average value (for given level)
	(do	(doseq [pos (range (count deck))] (fn1 pos))
   (let [vallist (for [pos (range (count deck))] (fn1 pos))]
		(/ (apply + vallist) (count deck)))))

(defn-memo rmCard [arr pos] (vec (concat (subvec arr 0 pos) (subvec arr (+ pos 1)))))  ;used outside of being hit (dealer or player)
(defn-memo addCard [arr card] (vec (sort < (conj arr card))))

(defn-memo BJHandVal [hand] 
  (let [tot (reduce + hand)] 
    (if (and (< tot 12) (= (hand 0) 1)) (+ tot 10) tot)))

(defn-memo dealerhands [[pHand dHand deck splits notes bet :as gm]]
	(let 	[up (dHand 0)
        dHands (for [i deck] (vec (sort < [up i]))) 
        hCombos (count dHands)]
   (filter #(not= % [1 10]) dHands)))

(defn-memo deal-e5 [[pTot dHand deckS notes :as gm]] ;add pHand, subtract deckS; for non-infinite decks
  (let [dTot (BJHandVal dHand)] 
	(cond (> dTot 21) 1
       (or (< dTot 17) (and (< dTot 18) (not= dTot (reduce + dHand)) (notes :hitsoft)))   
            (doseqfor deck1 #(let [newdeck (rmCard deck1 %) newdHand (addCard dHand (deck1 %))] (deal-e5 [pTot newdHand deck1 notes])))
		   (= dTot pTot) 0.5
		   (< dTot pTot) (if (notes :bj) 1.5 1)
		   (> dTot pTot) 0)))

(defn deal [[pHand dHand deck splits notes bet :as gm]]
  (let [nonBJHands (dealerhands gm) pTot (BJHandVal pHand)] 
  (/ (reduce + (for [hand nonBJHands]
         (deal-e5 [pTot hand deck (if (and (= (count pHand) 2) (= 21 (BJHandVal pHand)) (= splits 0)) (conj notes :bj) (disj notes :splitA))])))
     (count nonBJHands))))

(declare hit stand doubledown split surrender)
(def ops [hit stand doubledown split surrender])

(defn-memo dispatch [[pHand dHand deck splits notes :as gm]]
  (doseq [op ops] (op gm))
   (last (sort #(< (% 1) (%2 1)) (for [op ops] (op gm)))))

(defn-memo hit [[pHand dHand deck splits notes bet :as gm]]
	["ht" (if (not (notes :splitA))
         (doseqfor deck #(let [newdeck (rmCard deck1 %) newpHand (addCard pHand (deck1 %))]
                           (if (> (BJHandVal newpHand) 21)
						                   -1
                                ((dispatch [newpHand dHand deck1 splits notes bet ]) 1))))
         -10000) ]) 

(defn-memo stand [[pHand dHand deck splits notes bet :as gm]] ["st" (- (* 2 (deal gm)) 1)]) 

(defn-memo split [[pHand dHand deck splits notes bet :as gm]]
  ["sp" (if (and (= 2 (count pHand)) (not (notes :splitA)) (= (pHand 0) (pHand 1)) (< splits 3) (not (and (> splits 0) (= (pHand 0) 1))) )
		      (doseqfor deck #(let [newdeck (rmCard deck1 %) newpHand (vec (sort < [(pHand 0) (deck1 %)]))]
                          (+ ((dispatch [newpHand dHand deck1 (inc splits) (if (= (pHand 0) 1) (conj notes :splitA) notes) bet]) 1) 
                             ((dispatch [newpHand dHand deck1 (inc splits) (if (= (pHand 0) 1) (conj notes :splitA) notes) bet]) 1)) ))
		      -10000)] )

(defn-memo doubledown [[pHand dHand deck splits notes bet :as gm]]
  ["DD" (if (and (= (count pHand) 2) (not (notes :splitA))) ;sometimes no DD after split
            (doseqfor deck #(let [newdeck (rmCard deck1 %) newpHand (addCard pHand (deck1 %))]
                           (if (> (BJHandVal newpHand) 21)
						                   -2
                                (- (* 4 (deal [newpHand dHand deck1 splits notes bet])) 2)) ))
          -10000)] )

(defn-memo surrender [[pHand dHand deck splits notes bet :as gm]] ["sr" (if (= (count pHand) 2) -0.5 -10000)])

(defn from-the-top [] 
    (doseq [pHand combos i deck1] (dispatch [pHand  deck1 0 #{} 0]))
    (- (* 
         (/ (reduce + (for [pHand combos i deck1] ((dispatch [pHand  deck1 0 #{} 0]) 1)))
           (* (count combos) (count deck1)))
          (/ 161 169) )
        (+ (* 8/169 161/169))))

(defn hard-SS17 [] (for [j deck1] (for [k deck1] 
      [((dispatch [(vec (sort < [6 j])) [k] deck1 0 #{} 0]) 0) 
      (format "%.6f" (float ((dispatch [(vec (sort < [6 j])) [k] deck1 0 #{} 0]) 1) ))])))

(defn soft-SS17 [] (for [j deck1] (for [k deck1] 
      [((dispatch [[1 j] [k] deck1 0 #{} 0]) 0) 
      (format "%.6f" (float ((dispatch [(vec (sort < [6 j])) [k] deck1 0 #{} 0]) 1)))] )))

(defn pairs [] (for [j deck1] (for [k deck1] 
      [((dispatch [[j j] [k] deck1 0 #{} 0]) 0) 
      (format "%.6f" (float ((dispatch [[j j] [k] deck1 0 #{} 0]) 1)))] )))