set-with-functions.clj

;; pure fn implem                                                                                                                                    
                                                                                                                                                     
(defn set-empty []                                                                                                                                   
  nil)                                                                                                                                               
                                                                                                                                                     
(defn set-contains? [{:keys [inner element]:as s} e]                                                                                                 
  (and s                                                                                                                                             
       (or (= e element)                                                                                                                             
           (set-contains? inner e))))                                                                                                                
                                                                                                                                                     
(defn set-add [{:keys [inner element]:as s} e]                                                                                                       
  (if (set-contains? s e)                                                                                                                            
    s                                                                                                                                                
    {:inner s :element e}))                                                                                                                          
                                                                                                                                                     
(defn set-rm [{:keys [inner element]:as s} e]                                                                                                        
  (if (set-contains? s e)                                                                                                                            
    (if (= e element)                                                                                                                                
      inner                                                                                                                                          
      (set-add (set-rm inner e) element))                                                                                                            
    s))                                                                                                                                              
                                                                                                                                                     
;; unit tests                                                                                                                                        
                                                                                                                                                     
(t/deftest set-tests                                                                                                                                 
  (t/are [in ex] (= in ex)                                                                                                                           
         (-> (set-empty)                                                                                                                             
             (set-contains? 0)) nil                                                                                                                  
         (-> (set-empty)                                                                                                                             
             (set-add       0)                                                                                                                       
             (set-contains? 0)) true                                                                                                                 
         (-> (set-empty)                                                                                                                             
             (set-add       0)                                                                                                                       
             (set-rm        0)                                                                                                                       
             (set-contains? 0)) nil                                                                                                                  
         (-> (set-empty)                                                                                                                             
             (set-add       0)                                                                                                                       
             (set-add       1)                                                                                                                       
             (set-rm        0)                                                                                                                       
             (set-contains? 0)) nil                                                                                                                  
         (-> (set-empty)                                                                                                                             
             (set-add       0)                                                                                                                       
             (set-add       1)                                                                                                                       
             (set-rm        0)                                                                                                                       
             (set-contains? 1)) true))