wzorzec implementacji cofnij/ponów w clojure

Question

Czy istnieje ustalony wzorzec do implementacji funkcji cofania/przywracania w clojure lub ogólnie w fp?

W języku OO chciałbym iść z wzorcem polecenia, ale jak to jest wszystko o stanie zastanawiam się, czy jest to idiomatyczne robienie tego w clojure.

Czy są jakieś biblioteki, które mogą być pomocne?

Answer 1

Podobnie jak w przypadku wielu wzorców projektowych, można go zaimplementować jako funkcję w clojure. To zależy w niewielkim stopniu od tego, jak reprezentujesz stan w swoim programie (refs, atomy, agenci) w procesie jest bardzo podobny.

Po prostu chcesz dodać funkcję obserwatora do swojego stanu agent/ref/atom, który dodaje stan do listy cofania za każdym razem, gdy pojawia się aktualizacja. wtedy twoja funkcja cofania po prostu wyszukuje je na liście cofania. Ma to dobry efekt dodania twojego do listy cofania, pozwalając na ponowienie również

Moje pierwsze wrażenie jest takie, że ref s może być właściwym narzędziem do tego, ponieważ będziesz mógł przywrócić je wszystkie w skoordynowany sposób , chyba że możesz ograniczyć swoje programy do jednej tożsamości (w sensie Clojure), to nie potrzebujesz skoordynowanej aktualizacji, a agent będzie działał.

Answer 2

Ok zrobiłem to działa jak Arthur Ulfeldt zasugerował:

(defn cmd-stack [state-ref] 
    (let [stack (atom ['() '()])] 
    (add-watch state-ref :cmdhistory 
      (fn [key ref old new] 
      (let [redo-stack '() 
        undo-stack (conj (second @stack) old)] 
      (reset! stack [redo-stack undo-stack])))) 
    stack)) 

(defn can-redo? [stack] 
    (not (empty? (first @stack)))) 

(defn can-undo? [stack] 
    (not (empty? (second @stack)))) 

(defn undo! [stack state-ref] 
    (let [redo-stack (first @stack) 
     undo-stack (second @stack) 
     current-state @state-ref 
     last-state (first undo-stack)] 
    (assert (can-undo? stack) "cannot undo") 
    (reset! state-ref last-state) 
    (reset! stack [(conj redo-stack current-state) (drop 1 undo-stack)]))) 

(defn redo! [stack state-ref] 
    (let [redo-stack (first @stack) 
     undo-stack (second @stack) 
     current-state @state-ref 
     last-state (first redo-stack)] 
    (assert (can-redo? stack) "cannot redo") 
    (reset! state-ref last-state) 
    (reset! stack [(drop 1 redo-stack) (conj undo-stack current-state)]))) 

Ale co ja nadal nie bardzo rozumiem dlaczego. Od cofnięcia! i ponów! funkcje aktualizują obserwowany atom, czy obserwator nie powinien zareagować na to, a tym samym zepsuć stos poleceń przez przywrócenie cofniętej wartości?