Clojure immutability practice - clojure

Question

I´m trying to understand the Clojure´s immutability best practice and I have this simple example where I constantly re-declaring(updating) "new-orders" but I´m not sure if this is the right way.
(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)
Thanks,
R.

Answer 1

This definitely is not the right way to do functional programming in Clojure, or any other FP language. Your code is still essentially imperative, though you have used Clojure as the implementation language.
The right way is to create new data structure with modified content whenever you need a new version of some data structure. Something like:
(let [a []
b (conj a "order1")
c (conj b "order2")]
(println c))
In this case conj creates a new data structure by adding a new element to the structure given as parameter to conj. The old structure is not modified in any way, which means it's immutable.
If you really really need to have some sort of state, Clojure has primitives for that, like atom for example. But first try to write functional code without a modifiable central state.

Answer 2

Here is a more typical way of doing this example. It uses the spyx-pretty function from the Tupelo library, but you could substitute println if you want:
(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))
with results:
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"}