Clojure function to realise a sequence - clojure

Question

I have the following function to collect datomic transaction reports, output of this earlier question.
(def recreate-database
"Defines a function which when called will call each of the four given
functions and return a collection containing the output of each."
(juxt pt1-transact-schema
pt1-transact-data
pt2-transact-schema
pt2-transact-data))
The next step is that each of these functions may itself call not one but a series of transactions, so the complete result desired will be a nested collection of transaction reports for the initial database build.
I had the following, which was unsuitable, because when called from recreate-database above, only the last transaction report comes through, a function of course only returning its final form.
(defn pt1-transact-data []
(d/transact conn {:tx-data pt1-user-data})
(d/transact conn {:tx-data pt1-path-data})
(d/transact conn {:tx-data pt1-series-data}))
So I arrived at the following
(defn pt1-transact-data []
(map identity
[(d/transact conn {:tx-data pt1-user-data})
(d/transact conn {:tx-data pt1-path-data})
(d/transact conn {:tx-data pt1-series-data})
(d/transact conn {:tx-data pt1-path-series-data})]))
This works fine, except there's still incidental complexity. map identity is linguistically low level in relation to intended meaning here.
Hence thinking was, we just need to "realize the sequence", so I extracted:
(defn realize-all [coll] (map identity coll))
Then I remembered doall.
Just using that works here too.
So, is this the same as what doall does?
I note from (source doall) it doesn't appear the same, that leads to dorun, which leads to... recur.
So map identity or doall or dorun appear to serve similar purpose here.
Are these equivalent? Is there more to say?

Answer 1

why don't you just wrap it in a vector? that seems to be the easiest solution:
(defn pt1-transact-data []
[(d/transact conn {:tx-data pt1-user-data})
(d/transact conn {:tx-data pt1-path-data})
(d/transact conn {:tx-data pt1-series-data})])
or else you could use mapv:
(defn pt1-transact-data []
(mapv (partial d/transact conn)
[{:tx-data pt1-user-data}
{:tx-data pt1-path-data}
{:tx-data pt1-series-data}))