Können Daten zur nächsten Iteration (für ...) übergeben werden?

Question

Ich bin gerade dabei, clojure nach der Arbeit zu lernen und mache das, indem ich ein kleines Spiel mache (liebe die Quil-Bibliothek), um mich mit den verschiedenen Aspekten von clojure im Besonderen und FP im Allgemeinen vertraut zu machen.

So besteht meine Spielwelt aus 3D-Gitter von Kartendatenstrukturen (Vektor eines Vektors eines Vektors einer Karte). Ich möchte über jeden Punkt im 3D-Raum (Karte) iterieren und die Daten ändern, wenn eine Bedingung erfüllt ist. Dies war meine erste Lösung:

(die Spiel Datenstruktur ist das Spiel Zustand (eine Karte))

(defn soil-gen [game] 
    (let [world-x (game :world-x) 
     world-y (game :world-y) 
    world-z (game :world-z)] 
     (for [x (range world-x) 
      y (range world-y) 
      z (range world-z) 
      :when (> z (* world-z (rand)))] 
     (assoc-in game [:world x y z :type] :soil)))) 

Aber das gibt eine Liste der Ergebnisse (mein Spiel Zustand-Datenstruktur) jede Iteration statt einer Spieldatenstruktur. Ich sollte irgendwie in der Lage sein, das Ergebnis jeder Iteration zu wiederholen. So etwas wie loop/recur wahrscheinlich aber ich denke du kombinierst nicht recur mit für.

Jemand ein Hinweis?

dank

Answer 1

Was Sie tun können, ist reduce mit for verwenden, wie unten dargestellt:

(defn soil-gen [game] 
    (let [world-x (game :world-x) 
     world-y (game :world-y) 
    world-z (game :world-z)] 

    (reduce (fn [g [x y z]] (assoc-in g [:world x y z :type] :soil))) 
      game 
      (for [x (range world-x) 
        y (range world-y) 
        z (range world-z) 
       :when (> z (* world-z (rand)))] 
       [x y z])))) 

Answer 2

Sie wollen wahrscheinlich etwas wie reduce verwenden, um das akkumulierte Ergebnis zwischen jeder Iteration zu übergeben.

Vereinfachte Beispiele:

(reduce 
    (fn [m val] (assoc m val (str "foo" val))) 
    {}    ;; initial value for m 
    (range 5))  ;; seqence of items to reduce over 

=> {4 "foo4", 3 "foo3", 2 "foo2", 1 "foo1", 0 "foo0"} 

reduce ist in der Regel sehr nützlich, wenn so etwas Konzept eines „akkumulierten Wert“ in der funktionalen Programmierung. Es hat auch den Vorteil, sehr effizient zu sein.