curious, what's wrong with cheshire?

or data.json

data.json is fine, cheshire incurs a dependency (jackson) that is extremely problematic

Probably The most frequent dep compatibility issue in large apps

k, guess clj-http has the same issue with its dependency

has anyone tried to use the new java http client directly? how well does it lends itself to the task?

I suspect it would be pretty good, but it is hard to displace very entrenched libraries

At one point I created a stripped down version of clj-http that just used urlconnection (part of the jre) and I suspect something similar on the new http client would be good

But it might be a useful inflection point to ask if a new interface would be better, the new http client offers new features like websockets which clj-https API isn't great for, same for some new http2 features

yeah, writing a new library is probably a lot effort since just copying the clj-http API on top the built-in client is not a good idea as you said

everyone is going to have their own little wrapper for their use case

Hi! If you have created a protocol and want to define something that implements it, when do you use reify and when to use defrecord?

What's [C in (type (char-array "3"))? Why can't I do (conj (char-array "2") \j) ? (getting "[C cannot be cast to clojure.lang.IPersistentCollection") And what should I do instead if I want to add some char to the end of the result of char-array?

Is Heroku a reasonable first choice for deploying some Clojure / Clojurescript web apps?

@Here does anyone have any experience with the java,jdbc library, and doing a dryrun of a db query? I am wanting to do a dryrun but am not sure the library supports it.

Think people are using next.jdbc now.

Unfortunately I'm at the mercy of a legacy codebase

Though looking at the docs I'm not sure next.jdbc has a dryrun option either...

@carladrago maybe running your commands within a BEGIN transaction and ROLLBACK at the end?

what would a dryrun of a query do?

A 'pretend' query. It's for making sure the query does what you want it to before you actually run it.

I don't understand still, what does it return?

is it just like adding a LIMIT 0 to get back the result set metadata?

No, I think dry run is about reporting "If you ran this query, it will delete/modify 100 rows" without actually deleting/modifying. Also validates the query.

queries don’t delete things

They query

They mean query in the larger sense, not just SELECT.

I have a collection of filter functions (fns to be used with filter) if I call (filter filter-fn1 (filter filter-fn2 coll)), I get the result I expect but I can’t find a scalable way to combine filter-fn1 and filter-fn2 into a thing so I can just do (filter combined-filters coll). I thought I should just be able to comp them, but that doesn’t seem to work (just returns no items). suggestions?

Have a look at every-pred

thanks @aaron-santos, that worked perfectly

one other q, is the best way to use this with my list of filter-fns (apply every-pred filter-fns) ?

so all in all, (filter (apply every-pred filter-fns) coll)

Looks good to me 🙂

I ended up with (filter (apply every-pred (map make-filter-fn filters)) cards) which is great. Is that “too much” for 1 line? I’m used to the OO days where I’d probably break that up a bit

you can use transducers for that

(into [] (comp (filter filter-fn-1)
               (filter filter-fn-2))
      collection)

I expect to have a variable amount of filters (which are maps I need to convert to fns with make-filter-fn). what would it look like then?

(into [] (make-filter-tx filters) collection) where make-filter-tx is a function returning transducer assebled from filters

thanks, ill give that a shot

So this is neat:

> #inst "2020-03-27"
#inst "2020-03-27T00:00:00.000-00:00"
>

(str *1)
"Thu Mar 26 17:00:00 PDT 2020"

(str (.toInstant *1))

Cool! Thanks!

I’m working with a library that is emitting some output that I think would be useful through clojure.tools.logging. How can I find or redirect that output to somewhere I can read it?

Is there a convenience method for converting false to nil ? I've got a situation where I want to do something like (and a b c) but if a gives false I really want nil there (correction: "and" not "or" function)

^^yah, sorry, mistyped

oh, it's harder with and

({false nil} x x) replaces false with nil and otherwise returns x

(ins)user=> ({false nil} false false)
nil
(ins)user=> ({false nil} :a :a)
:a

Gotcha

(or (and a b c) nil)