Is there a more idiomatic way to handle this?

(mapcat #(clojure.string/split % #" ") ["I am groot"])

-> ("I" "am" "groot")

is there some reason that’s not sufficient?

I guess maybe you don’t like having to wrap vector on the input?

(clojure.string/split "I am groot" #" ") is basically same

I guess if that vector is only ever expected to be of length 1 then (clojure.string/split (first v) #" ") may be more intention-revealing. but if not what you have makes sense

+1

(into [] (mapcat #(clojure.string/split % #" ")) ["I am groot" "hey there"]) ;; transducer style

not sure what you care about whitespace, but #"\s" uses Java regex pattern for whitespace, so will catch tabs etc

I think it's just the idea of structuring a nested map using map and then destructuring it with cat. But I suppose that has to happen with any implementation really. Probably just overthinking it 😃

it's been a while since I've thought about them but I think the transducer version doesn't have that interim structure

Is there a function that splits a collection into two groups based on bool. e.x. [(filter coll) (remove coll)]

@nbardy: is partition-by, or group-by what you want? (vals (group-by pred coll)) should be pretty close.

@srihari (vals (group-by pred coll)) does what I want. Wondering if there was a single function for it.

I'm trying to learn the very basics of clojure now by reading some csv data, parsing it into a map and playing around with transforming it in different ways. What's a good clojurian way to filter a sequence of maps based on the values of a particular key? Data looks like this:

[{:a "" :b "foo"}, {:a "2", :b "bar"}, {:a "3", :b "baz"}]

So I'm getting this weird error where a specific "namespace is not found." However I have the namespace clearly defined and it works occaisonally (I'm doing this in emacs with cider if that matters). It especially works after I run cider-load-buffer (at least usually)

what would cause that/how to fix it?

@emilaasa use filter with a predicate that returns false when the :a value is ""

@emilaasa (filter #(not (empty? (:a %))) your-collection)

I’m sort of confused about how cljs-http works in terms of Clojure data structures. I have two functions that are simply making an HTTP GET request, returning the body of the response, and attempting to print the first item in the response collection:

(defn get-http-result [path callback-fn]
  (go (let [response (<! (http/get (str js/location.pathname path)))]
        (callback-fn (:body response)))))

(defn get-available-commands []
  (get-http-result "/commands" #(prn (first %))))

The issue I’m running into is that (get-http-result "/commands" #(prn (first %))) seems to only print [ to the console log, rather than the first item in the collection.

I guess should also say that the response body looks like this: [{"section":"System Status","command":"Media Files Uploaded","important":true},{"section":"System Status","command":"Temperature","important":false}]

Are functions like swap!, alter and commute synchronous? I mean, do they block until completion?

they're synchronous, that is, the computation is guaranteed to be terminated when they return

but they don't really block the thread, they retry until the transaction is consistent

@leonoel nice, thanks! Still related to causing side effects: What if I want to do something like a “Java business transaction”? Say that I have to send an email, put a message on a MoM queue and persist to a database. How do I prevent these from being repeated every time the transaction retries? If the answer to this is long, you can give me some terms or key-words for a research

you can use STM with agents, they support this use case

all sends to agents performed during the transaction will be delayed until the transaction is successful, so they will effectively happen just once

Makes sense. The side effect will be caused on the async execution, right? Stretching this just a little bit more: what if the side effect fails? For example, what if the email server fails and the other two servers commit the changes? In Java EE (and in other places too, but I’m really used to Java EE) we have the two-phase commits to address this (not completely, but with an extra layer of certainty). Is there anything similar in Clojure or is this a simple matter of dealing with it manually?

there is no such mechanism out of the box, you will have to handle async errors manually

I’d take a few minutes with the Google - unlike the Java EE world, the Clojure community is very much about composing smaller, specialized libraries to do what you want

I’d bet someone has written a thing to abstract “handle async failures gracefully” and put it on Clojars, is what I’m saying.

I see. Well, that is a very difficult problem, because if you try to be prepared for every possible failure, things will get complicated 😅

@chris_johnson that is beautiful! I’m loving the idea of composing the solutions from small libraries that do one thing right, feels a lot like unix

Welcome to the Clojure community! You’re going to like it here. 😄

@lvbarbosa I think many developers, and perhaps most clojurists, would look to publish a message to a durable topic and have e.g. the email system subscribe to that topic, instead of trying to ensure multi-party transactions resolve all effects synchronously

@donaldball I see, makes more sense!

Let's say I have a vector [a a a a a a a] where a is a gigantic map; does the vector contain 7 copies of a in memory? Or is the value of a cached and referenced for each (to reduce memory)?

@dadair There will only be one instance of the map; this is one of the benefits of persistent collections. 🙂

in this case I think the fact that java doesn’t have value types would ensure this anyway

thanks, I assumed as much, wanted to confirm before propagating a huge map to a bunch of smaller datastructures as "metadata"

(defn setup-types [userid]
    (import-action-template 1 userid) 
    (import-action-template 2 userid) 
    (import-action-template 3 userid) 
    (import-action-template 4 userid))

(map #(write-to-db! %) list-of-maps) 

To answer myself, had to put a (doall) around the (map)

or you can replace map with run! - doall is for when you still need the return value of map, and dorun is for when you need an argument arity that run! doesn’t support but don’t need the return value, and run! is for when you don’t need the return value and are only providing a function and a single collection as args

thx. will check that out