Is there a better way to achieve (keyword (name :foo/bar)) ?

@lockdown- To "unqualify" a keyword? No, that seems a reasonable way to do it.

ok, thx

When using the ->> macro, how to take the result of the last line (which will be a seq of some sort) and operate on each part. In other words, how can i accomplish `(->>

`(->> (returns-seq) (for [x ,,,]))`

I am looking into the as-> macro but I am having trouble understanding how it works

@mbbailey96 start your pipeline with ->

(-> expr
    (->> your pipeline here)
    (as-> s (for [x s] ,,,)))

@seancorfield thank you!

Hello all, how to I pass operator for a filter? I know that is wrong, but how is the correct way to do this?

(defn- todos-alarmes-filtrados-por-chave [endereco chave valor & {:keys [operador] :or {operador .contains}}]
  (->> (alarme/todos-alarmes endereco)
       (filter #(not (nil? (chave %))))
       (filter (apply operador (chave %) valor))))

When using protocols, do you usually use them for your SPI's? I've started to get the habit to define protocols for all my SPI actions (save user-information to a database etc), since it is easy to create a "FakeStorage"-implementation.

@fabrao Not sure what your question is here? What doesn't work about that code?

@jarvinenemil Perhaps you are over-using protocols?

Unable to resolve symbol: .contains in this context <-

I don´t know how to define .contains as 'default' operator

Oh, @fabrao you can't use Java methods directly you need to wrap them in Clojure functions: #(.contains %1 %2)

😐

Yeah @seancorfield i still get the notion that I am thinking too much in Java-interface terms when using Protocols in Clojure (sometimes).

There's no point in using protocols unless you have multiple implementations for them, IMO.

{:keys [operador] :or {operador #(.contains %1 %2)}} ?

@fabrao Something like that, yes

@seancorfield currently I have two record implementations for each protocol, one implementation that runs in the prod-environment and one that is used in tests

Mmm, still sounds a bit unnecessary...

That's a very OO way of dealing with mocking for tests.

Indeed, I need to find another way of dealing with the mocking for tests. Thinking of using with-redefs instead

(I did read that one should avoid that though)..

If you can refactor to pure data and function arguments, you'll probably be better off...

I will try some ideas, in my current implementations all state is defined as function arguments. I just need to remove some records 🙂

I found this comment section quite interesting: (Protocols and records): https://www.reddit.com/r/Clojure/comments/42nkkw/how_i_use_component/

(defmethod pp :a [ g #SOMETHING]...) is #_SOMETHING like a comment?

yes

thanks

it's a special reader macro that says to skip the next form read. So here SOMETHING will be read (as a symbol) and thrown away

thanks alex

one useful variant:

user=> {:a 0 #_#_ :b 1 :c 2}
{:a 0, :c 2}

(maybe that only works if you consciously adapt the idiom, but #_#_ is pretty unmistakable once you learn to recognize it)

That means skip : b and 1? (the next two forms)?

right

cool

thanks!

another variant I like - sadly cljfmt doesn't like it though:

#_
(defn broken-on-load
 "commented out for now, but will uncomment when it doesn't break the namespace" 
 []
 ...)

the advantage is in git it doesn't add whitespace diffs

and it's less invasive than (comment ...) which would do the same thing (and imposes indentation based on standard paren nesting rules, where the reader macro doesn't)

makes sense (once you learn to recognize it, as you said before) !