Is there a non-verbose way to get a submap with only a few keys out of many?

Like, going from a map with {:a "a"} for the entire alphabet to just the keys for the letters in "cup"?

Ha! nevermind. I found it. https://clojuredocs.org/clojure.core/select-keys

@achythlook There’s also https://clojuredocs.org/clojure.set/rename-keys which comes in handy on occasion.

Any example on how to refresh ~/.clojure/deps.edn and put some exclusions in packages??

@konanki.sivaram Not sure what you mean by "refresh" in that context. As for :exclusions, you just put them in the map with :mvn/versions.

See https://clojure.org/reference/deps_and_cli#_dependencies

@seancorfield I did, uncomplicate.neanderthal gives me an error. But the same thing in lein/project.clj does not give any error

Show your deps.edn file and the error you get...

(the artifact name would be uncomplicate/neanderthal -- not .)

Hello, do you have a hint how I get a clojure source file parser? One which does not throw away formating (spacess, new-lines, etc)? I need to read a clj/cljs/cljc file in Clojure+Clojurescript, make some changes and save it again without destroying the formating. I could not find a library for this purpose. Or could I do this with some Clojure built-ins? Thank you!

hi clojurians, May I ask what rpc framework do you use in production?

recently I want to use nodejs to RPC request clj backend services, need some help please

@witek use something like https://github.com/xsc/rewrite-clj, there also a cljs fork https://github.com/rundis/rewrite-cljs

@witek AFAIK the downside is that they use their own reader, so it might not be 100% accurate, if you need highest fidelity you could use tools.reader and jump through hoops to preserve whitespaces during reading, you can abuse cljs.tools.reader.reader-types/log-source* for that. I’ve successfully done it here (at least for cljs): https://github.com/darwin/plastic/blob/master/src/meld/meld/parser.cljs#L32 https://github.com/darwin/plastic/blob/master/src/meld/meld/tracker.cljs#L28

ah, here is some rationale: https://github.com/darwin/plastic/blob/master/src/meld/meld/core.cljs#L7-L43

I just finished reading the results of the 2018 survey. Should I be concerned that as I encourage our team to use more Clojure, that we are going to see it become marginalized in the next few years? Several of the negative comments indicated that could happen based on the community, docs, inaccessibility to newcomers, core direction, etc.

it’s important to keep in mind that the vast majority of people that filled out the survey did so without entering comments or with positive comments. The relatively small number of negative comments get an outsized amount of attention (imo). Which is not to say that there aren’t things to work on.

Greetings Mr. Miller. I've been studying

Clojure since 2015

I just got my first Clojure job (professionally) two weeks ago

I'm having the funnest time of my professional career

nice!

Thanks for everything you do for the community.

So, I hear a lot of gripes about docs. I tweeted that I’m willing to help, but no one has taken me up on the offer. So, I’ll ask again: is anyone here working on a Clojure project that would feed me the bits and pieces to help flesh out the docs?

if you want to help out on the Clojure web site, see https://github.com/clojure/clojure-site/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22

How difficult/complex is the process for review and approval?

I’m pretty sure that although I can get started with something, it will take several revisions to make sure it’s accurate and useful.

just a matter of filing a PR which I’ll review

it’s ok if that takes a few rounds

great!

I might dive into some features I’ve not used, so it might take a few more rounds than normal. But that should produce docs better for the beginning experience, I’d think.

@jmckitrick That's awesome. Ping me if you need another set of eyes on some of those drafts.

Will do.

The first I’m looking at is here: https://github.com/clojure/clojure-site/issues/120

But I see that there have been docs added here: https://clojure.org/guides/weird_characters#tagged_literals

So just to clarify, is there more to be done?

prob better to have this discussion on the issue, but that is just an example of syntax, would be better to document #inst and #uuid in particular elsewhere as they are provided in core. #inst has a wide variety of formatting options as well.

should be under /reference somewhere

ok

prob in the region of https://clojure.org/reference/reader#tagged_literals

changelog docs are at https://github.com/clojure/clojure/blob/master/changes.md#211-instant-literals

that’s good starting text

ok

beyond that, the code is probably the next best place for information

@jmckitrick super power: write up what you actually ended up doing in the process of getting a new doc live, and publish that far and wide. let’s show folks how hard this isn’t

Good suggestion!

<opens evernote to doc the doc process>

@jmckitrick Having done it for the REPL guide recently, I can testify that the contribution process was pretty smooth, even though that was a big change to the documentation.

It really irritates me how beautiful the docs are for some languages, and how such a great language as Clojure has everyone so busy coding, no one is writing docs to keep up.

No-one is an overstatement, there are some wonderful clojure docs, by @alexmiller and others, but more is obviously better!

re updating the docs, see (or update!): https://clojure.org/community/contributing_site https://clojure.org/community/editing

@pesterhazy more is not obviously better

One way people get to “more” is by embedding narratives everywhere they might be needed, rather than linking

another way people get to “more” is incrementally addressing singular complaints rather than stepping back and re-organizing

in those two cases more is not better

Hi, is it possible to create a library that has both clojure code and clojurescript code + a external javascript dependency?

Hi!

@alexmiller @john Do I ‘assign’ you guys, request your review, or something else?

I’ll see a notification for any pr you create, but also feel free to explicitly request a review

Is there a tool to extract a list of environment variables that are being read from our code through calls to @weavejester's environ's env function? Or maybe even a similar library that allows to specify a documentation string and default values and generates --help output and possibly *roff / mandoc / CommonMark / MarkDown?

@jmckitrick you can just ping me here on slack and direct me to any docs you want me to review. You can assign to me in github as well, either way.

@john https://github.com/clojure/clojure-site/pull/256

hmm, if I introduce a macro that requires another namespace as part of it’s output, is there a way to make sure the namespace that invokes my macro doesn’t also have to require the namespace?

(defmacro foo [args]
  `(do (some.namespace/do-foo ...)
)

or would my macro have to dynamically require the some.namespace as part of its output?

Can I somehow declare a dependency on a non clj(s) file? My use case is that I have a macro and it slurps a file and sets a var. If the file is updated the macros are naturally not recompiled. Can I somehow make that happen? I know I could by using a clj file instead of a normal file but that feels yucky for config. If possible I’d gladly use an edn file.

@jmckitrick nice work on the data literals docs! That's definitely going to be helpful for new folks.

What's the correct way to extend a protocol for hash maps generally?

Usually not a good idea but can extend to clojure.lang.IPersistentMap

No way to specify priority if more than one impl matches though (if I'm not mistaken?)

right - generally it’s best to scope any protocol extensions as narrowly as possible, preferably only to concrete types

why not a good idea @alexmiller?

because IPersistentMap is a very generic interface which applies to all maps and record types

ok but you're not saying that extending a protocol to an interface is a bad idea then right?

so you are likely to create a situation where you conflict with other extensions and create ambiguity

that's what I understood you meant

there is nothing wrong with extending a protocol to an interface

right, cool

I get what you mean then

my “Usually not a good idea” is in particular targeted at “extend a protocol for hash maps”

cough https://dev.clojure.org/jira/browse/CLJ-1807 :)

I am aware :)

(i know rich doesn't like it)

Rich and I are at odds on that one

I think it's fundamental for allowing proto->interface extension tbh

but it's true that it's rarely needed

well, agreed :)

I got a question; I have an array of integers I want to convert to a byte[] of the ints equivalent hexes

So from [60, 129...] I want to go to [3c, 81...]

but not as Clojure's PersistentVector, as a Java byte array

got it, nm

Man, the clojure community is a strange beast

I wrote a blog post trying to advocate for it's use, and it seems almost like it was a wrong course of action

Question: I came across a stackoveflow post yesterday asking why recur wasn't working but standard recursion was. Turned out the problem was that recur doesn't gather rest args into a seq... which is documented behavior and highlighted in the clojuredocs sample below: `; Note that recur can be surprising when using variadic functions. (defn foo [& args] (let [[x & more] args] (prn x) (if more (recur more) nil))) (defn bar [& args] (let [[x & more] args] (prn x) (if more (bar more) nil))) ; The key thing to note here is that foo and bar are identical, except ; that foo uses recur and bar uses "normal" recursion. And yet... user=> (foo :a :b :c) :a :b :c nil user=> (bar :a :b :c) :a (:b :c) nil ; The difference arises because recur does not gather variadic/rest args ; into a seq.`

oops messed up the formatting there - sorry

So - I've never had an issue with this before, probably because I only use recur in conjunction with loop, so any gathering of rest args would occur in context of a loop binding

It's a total non-issue to me, but it got me wondering why there would be a difference in semantics. I found plenty of material discussing the difference, but not the why. Would anybody be able to shed some light on this?

added a properly formatted snippet from the docs

it is mostly because the code that supports var args and the code that compiles loop/recurs don't know anything about each other

when you compile a function the varargs support sort of lives outside outside of the function, so by the time the function body begins executing it is passed a collection, an the recur point (basically a jump target) is at the start of the function body

you dont need to “call” a macro from in a macro, right? if you emit the macro it will get immediately unrolled right?

yeah - if you generate a valid expression it will automatically execute

i.e (defmacro foo [] ...) if I just emit this

(defmacro bar [] `(do (foo ...))

`(do ~(foo …))`

@hiredman not sure I follow

if you pass multiple args they are gathered at call time

they are gathered in some machinery in clojure.lang.AFn between the call site and before the actually function body starts executing

OK .. maybe i should just look at the source for that and it'll be more clear

I doubt it 🙂

i've never really encountered a problem with this before, it just caught me by surprise when reading the docs

seems inconsistent for such a remarkably consistent language

but recur being a jump back to the top of the function body doesn't pass through that machinery

ok that makes sense actually

is it fair to say it's more like going to the top of the body as opposed to re-passing arguments

e.g. sort of like javascript hoisting

you just re-bind vars locally at the very beginning of the body, but never call it again

@lwhorton your first example is correct

@lwhorton the macro generates code (text) that is then evaluated after generation

not text, data

thanks for clarifying

:thumbsup: that’s good, thanks. my issues is elsewhere (to the macro bookstore!)

there is a pretty good one "mastering clojure macros"

i haven't read it all yet, but it's been helpful so far

most importantly it's concise with lots of code samples, not a tomb of fluff chatting you up 🙂

:thumbsup: for mastering clojure macros, really useful book