abstract algebra helpers

defring.clj

(defmacro defring                                                                                                              
  [additive-identity                                                                                                           
   multiplicative-identity                                                                                                     
   add
   negate                                                                                                                      
   multiply]                                                                                                                   
  `(let [add# ~add
         negate# ~negate                                                                                                       
         multiply# ~multiply]                                                                                                  
     (defn ~'+                                                                                                                 
       ([] ~additive-identity)
       ([x#] x#)                                                                                                               
       ([x# y#] (add# x# y#))                                                                                                  
       ([x# y# & zs#] (reduce add# (add# x# y#) zs#)))                                                                         
     (defn ~'-                                                                                                                 
       ([x#] (negate# x#))                                                                                                     
       ([x# y#] (~'+ x# (negate# y#)))                                                                                         
       ([x# y# & zs#] (~'+ x# (negate# (apply add# zs#)))))                                                                    
     (defn ~'*                                                                                                                 
       ([] ~multiplicative-identity)
       ([x#] x#)                                                                                                               
       ([x# y#] (multiply# x# y#))                                                                                             
       ([x# y# & zs#] (reduce multiply# (multiply# x# y#) zs#)))))        

I don't think I'm using this properly:
(defring (range) (range) clojure.core/+ clojure.core/- clojure.core/*)

Your additive identity should be 0, not (range), and the multiplicative identity should be 1, not (range).