Clojure不変性練習

Question

Clojureの不変性のベストプラクティスを理解しようとしていますが、私は常に新しい注文を再宣言（更新）するこの簡単な例がありますが、これが正しいかどうかわかりません方法。

(defrecord Order [fplate splate]) 

(def new-orders clojure.lang.PersistentQueue/EMPTY) 

(defn add-order [orders order] 
    (conj orders order)) 

(defn cook [order]()) 

(defn cook-order [orders] 
(cook (first orders)) (pop orders)) 

;;order1 
(def o1 (->Order "Soup" "Fish&Chips")) 
(def new-orders (add-order new-orders o1)) 

;;order2 
(def o2 (->Order "Salad" "Hamburger")) 
(def new-orders (add-order new-orders o2)) 

;;order3 
(def o3 (->Order "Rice" "Steak")) 
(def new-orders (add-order new-orders o3)) 

;;cook order 
(def new-orders (cook-order new-orders)) 
(peek new-orders) 

おかげで、 R.

Answer 1

ここでは、この例を行うためのより一般的な方法を示します。それはspyx-pretty機能from the Tupelo libraryを使用していますが、あなたがしたい場合は、printlnに置き換えることができます：結果と

(ns tst.demo.core 
    (:require [tupelo.core :as t])) 

(defrecord Order [fplate splate]) 

(def orders-queue (atom [])) 

(defn add-order [order] 
    (swap! orders-queue conj order)) 

(defn cook [order] (println "cooking: " (pr-str order))) 

(add-order (->Order "Soup" "Fish&Chips")) ; order1 
(t/spyx-pretty orders-queue) 

(add-order (->Order "Salad" "Hamburger")) ; order2 
(t/spyx-pretty orders-queue) 

(add-order (->Order "Rice" "Steak")) ; order3 
(t/spyx-pretty orders-queue) 

; cook orders 
(newline) 
(doseq [order @orders-queue] 
    (cook order)) 

：

orders-queue => 
#<Atom@4147f771: [{:fplate "Soup", :splate "Fish&Chips"}]> 

orders-queue => 
#<Atom@4147f771: 
    [{:fplate "Soup", :splate "Fish&Chips"} 
    {:fplate "Salad", :splate "Hamburger"}]> 

orders-queue => 
#<Atom@4147f771: 
    [{:fplate "Soup", :splate "Fish&Chips"} 
    {:fplate "Salad", :splate "Hamburger"} 
    {:fplate "Rice", :splate "Steak"}]> 

cooking: #tst.demo.core.Order{:fplate "Soup", :splate "Fish&Chips"} 
cooking: #tst.demo.core.Order{:fplate "Salad", :splate "Hamburger"} 
cooking: #tst.demo.core.Order{:fplate "Rice", :splate "Steak"} 

Answer 2

は、これは間違いなく、Clojureの中に関数型プログラミング、または任意の他のFP言語を行うには正しい方法ではありません。 Clojureを実装言語として使用していますが、コードは本質的に必須です。

正しい方法は、新しいバージョンのデータ構造が必要なときはいつでも、変更された内容の新しいデータ構造を作成することです。何かのように：

(let [a [] 
     b (conj a "order1") 
     c (conj b "order2")] 
    (println c)) 

この場合、conjは、conjにパラメータとして与えられた構造体に新しい要素を追加することによって新しいデータ構造を作成します。古い構造は決して変更されません。つまり、それは不変です。

本当に本当に何らかの状態が必要な場合、Clojureには、原子などのプリミティブがあります。しかし、変更可能な中央の状態を持たない機能コードを書くようにしてください。