Good morning everyone.. I'm wondering about mapcat. I was a bit surprised that it returns a list rather than respecting the type of its input. For example, I expected that if I mapcat a sequence of sets, the result would be a set, but alas it is a list (mapcat identity #{ #{1} #{2} #{2 1} }) returns (`1 2 2 1)` rather than #{1 2} . Should I construct my own application specific flatmap function, or does such a function already exists. Clearly I can do what I want using reduce and union .

Is there an easy way to convert from kebab-case to snake-case in jdbc? My api is using kebab-case and I’m using postgresql with snake-case

Hi I am a newbie at Clj. I am running my repl in IntelliJ Idea, and I want to load my dev config (dev.edn) and fully start my program (which reads from JMS queues) However after I start my repl and I send (dev) I don’t see that my app starts running. My question is is there a way I can fully start my app using config in my dev.edn than just run in repl? Any links that show me how to use config etc would be helpful too…Thank you

I found the unify function in https://clojuredocs.org/clojure.core.logic/unify, what is it? It's not marked as dont-use-me, it just has blank documention.

I'm looking for a map-like version of every which takes multiple sequence arguments and an n-ary function: i.e. (every < '(1 2 3 4) '(10 20 30 40)) ? I didn't see one in the every/every? variants. (every f '(1 2 3) '(10 20 30) '(100 200 300) '(1000 2000 3000)) would expect f to be a 4-ary function.

I'm looking at the sort function https://clojuredocs.org/clojure.core/sort. for the 2-ary form, it says I need a comparitor and that

comparator must implement
java.util.Comparator

Is it just a function which will always return 1, 0 or -1 on any input encountered during the sort?

or is it more complicated than that?

I think the Clojure website does a great job at that

https://clojure.org/guides/comparators

Yeah, that’s probably your best but, and also if you type (javadoc java.util.Comparator) in the REPL the Java documentation will open up in your browser.

Might be helpful, might not, but it’s good to know.

The compare function is a nice example.

I looked over https://clojure.org/guides/comparators, It seems to me that as long as my function (fn [a b] ...) accepts any value which will be encountered during the sort, and returns 1, 0, or -1 enforcing a total ordering, then that is good enough without having to understand how to implement a java interface. Am I being naive?

Looks like it ought to work

The “must implement” language sounds like you need to implement the actual interface, but there’s no sign of that in the guide. I’d try it with a simple fn, and if that works, build the full-blown comparator.

Hello, I'm having hard time understanding how does the double evaluation happen in this piece of code from clojure for the brave and true: https://gist.github.com/gabbigum/e033175ed4773a03156b240fddd4fa26 , can somebody explain it?

@40441590 ~to-try gets replaced with the input

both places ~to-try exists

(defmacro report
  [to-try]
  `(if ~to-try
     (println (quote ~to-try) "was successful:" ~to-try) ;1st instance that gets replaced by input in ~to-try
     (println (quote ~to-try) "was not successful:" ~to-try))) ;2nd instance replaced by input in ~to-try

The macro does NOT evaluate the if statement.

because of the front quote `(if ~to-try

macro means meta code, or code describing other code, so it's not exactly evaluate-able until it becomes actual clojure (and is not just macro language)

Thank you very much!

you are very welcome, you chose an excellent question

@jimka.issy sort itself uses the compare function I posted the docs for (above), which is a plain function. So a plain function should work 🙂 See (source sort)

Does it make sense to store a collection of agents inside an atom? I'm thinking of changing my huge-atom-of-maps to a huge-atom-of-agents (for a simulation game) and I'm wondering if that's a good idea. In particular I'm trying to speed the game up, and while I don't expect agents to be "faster" than an atom, I'm thinking it might allow my code to be more flexible in so far as allowing the game objects to alter each others state or execute operations asynchronously.

I glanced at the iconic ant sim to see how it's done there but it actually didn't run on my computer, so I wasn't able to quite tease apart how it worked. For one thing, I don't see a way to change the number of ants after the simulation in in progress (could have missed it though)

Is there a way to tell the pretty printer, within cider, to print quoted lists as '(1 2 3) rather than (quote (1 2 3)) similar for quoted anything?

there is support in the clojure printer to do this

How does it work, is it a global setting, or do I have to pass a flag every time i call print?

I don't remember, trying to find an example. It's obscure enough that I have to look it up every time. :)

what exactly are you doing where you're seeing that?

pprint's default behavior actually does this already

user=> (println ''(1 2 3))
(quote (1 2 3))
nil
user=> (pprint ''(1 2 3))
'(1 2 3)
nil

it is the output of clojure.test in the emacs clojure repl. I'm seeing messages like the following:

FAIL in (t-canonicalize-pattern-once) (form-init4386036104585295471.clj:140)
canonicalize-pattern-once
not or 2
expected: (= (quote (:and (:not :clojure-rte.core-test/Cat) (:not :clojure-rte.core-test/Lion))) (canonicalize-pattern-once (quote (:not (:or :clojure-rte.core-test/Lion :clojure-rte.core-test/Cat)))))
  actual: (not (= (:and (:not :clojure-rte.core-test/Cat) (:not :clojure-rte.core-test/Lion)) (:and (:not :clojure-rte.core-test/Lion) (:not :clojure-rte.core-test/Cat))))

> reading https://clojuredocs.org/clojure.core/contains_q the claim is that there is no basic function to determine whether a given element is in a collection. A poster suggests the following to detmine whether 1 is an element of the sequence. Not sure why the quote is missing in the example, perhaps just a typo > > is this good advise? Seems weird to me that no such function exist. Of course I can write my own using loop/recur ... or some

(some #(= 1 %) (1 2 3))

there is intentionally no "linear search in a sequential collection" function (`some` is probably the closest) - in general the more Clojurey advice would be to put that data in a hash-indexed collection (map/set) and look it up

I'm reducing a symbolic expressions such as (op a b c d e a b c d e ) and if I find the identity element for the given op, I want to remove it.

I'd use remove then

Run a (filter) first then?

If I use remove, how do I know whether it got removed if I don't know whether it was there in the first place? That's fine. I happy with some.

Do a partition-by. EDIT: That's not perfect. Let me look for something better.

remove won't tell you that directly. You could do = on return value vs. input value, but that is linear time.

yes remove followed by = is linear in time and space, and find would be linear in time and constant in space

I am not aware of any built-in function that behaves like remove but also returns whether it removed any elements. Not difficult to write, of course.

speaking of partition-by I found group-by for another purpose entirely. Is there a better way to group-by a Boolean predicate, effectively splitting the sequence into a good and bad collection?

Do you actually need a separate true/false return value indicating whether it removed any elements? Does your calling code actually care for some reason?

group-by with a function that returns true or false is a good way to split into good/bad. I am not aware of a built-in that does the job any better.

scala has a function, i forget the name, friend of group-by which takes a collection and a Boolean predicte and returns a pair of collections, for the true and false items.

again, it is easy to write.

I guess I am having a hard time thinking of what is "wrong" with group-by for that purpose. You don't want the overhead of creating a 2-element map?

I don't see how you could possibly get away from that in the JVM

it would presumably just return a tuple.

a 2-element map in Clojure is often an array of 4 elements under the hood.

well, a 4-element array, plus another object that points at it.

would split-with help here?

user=> (split-with odd? [1 3 5 6 7 9])
[(1 3 5) (6 7 9)]

I guess not, you want more group-by behavior

I often have written something like

No, that doesnt split into an odd set and even set

(let [{odds true, evens false} (group-by odd? [1 3 5 6 7 9])]
  (println odds evens))
;; [1 3 5 7 9] [6]

you could probably macro that into something you prefer

So, true and false are functions?

keys

no reason to macro that. a normal function works just fine.

well, keys into the map in this particular context. They are literal constant Boolean values, in general.

Okay, so in destructuring the keys are actually looked up by get?

I was thinking (true {true :true false :false})

you can't invoke true

you can examine what destructuring converts to using the (undocumented) destructure function

That's a nice tip!

user=> (pprint (destructure '[{odds true, evens false} (group-by odd? [1 3 5 6 7 9])]))
[map__161 (group-by odd? [1 3 5 6 7 9])
 map__161 (if (clojure.core/seq? map__161)
            (clojure.lang.PersistentHashMap/create (clojure.core/seq map__161))
            map__161)
 odds (clojure.core/get map__161 true)
 evens (clojure.core/get map__161 false)]

I actually wanted something like (juxt false true) but that won't work because true/false cannot be invoked.

(juxt false? true?) maybe?

I guess that won't work on a map

you'd really need a get with those

or (juxt #(get % false) #(get % true)) ?

or #(map % [false true]) where the arg is your map

Can someone explain to me the purpose of (deref)? For example;

user=> (def a (atom 99))
#'user/a
user=> a
#<[email protected]: 99>
user=> @a
99

the use case for an atom is for it to be a location

so you need two sorts of operations: operations on the location itself, and operation on the data in that location

you can have a function like (defn attach-foo [a] (swap! a conj :foo)) - it takes an atom, and replaces the contents using conj

you can't do that if using a is the same as using @n3k05yd

it's almost like an assignable pointer, but it has rules about how it can be updated

in fact, even (swap! a conj :foo) would break if a was the same as @a

Interesting. Thanks @noisesmith!

@darrell vars work the opposite way - if you have (def a 99) a gives you 99, but #'a gives the var itself

which is useful if you need the metadata on the var, or you need to manipulate it directly, or you want some function to have a handle to the var and not the value in it

and (deref #'a) and @#'a give you 99 as well as making you feel like a perl programmer again 😆

That makes sense. I think I was conflating an atom with a var.

lol

ins)user=> (def a (atom 99))
#'user/a
(ins)user=> #'a
#'user/a
(ins)user=> a
#object[clojure.lang.Atom 0x4e61e4c2 {:status :ready, :val 99}]
(ins)user=> @a
99
(ins)user=> @@#'a
99

please avoid @@#'foo in real code!

Yeah, that seems a tad unnecessary. 😄

reference types ("boxes") vs. values (usually not in a box, but can be)

reference types include vars, atoms, refs, agents

learn how vars work first @darrell

vars are by far the most common, followed by atoms

refs and vars have some convenient behaviors too:

(ins)user=> (def r (ref {:a 0}))
#'user/r
(ins)user=> (r :a)
0

a ref or var, when used as a function, invokes the thing it contains

(it would be nice if atoms did this too, but they don't)

So what is a scenario under which it’s preferential to use an atom over a var?

when you want to change a shared(think threads) value

even zero atoms 🙂

ideally zero, yes

how can i construct a ratio (eg 22/7) with expressions? (+ 20 2)/(+ 5 2) doesn't work