@noisesmith That acts just like before (didn't figure out what to do with ^:replace, or ^:merge). I'll try asking on #leiningen.

the ^:replace goes after the key and before the value in the project map

what happens specifically with :jvm-opts is that it concatenates options, and if two options contradict, you might get an undesirable choice from the vm, in which case you ahve to use ^:replace to get a good command line generated

So something funky is going on with my classpath. Right now my config namespace "cannot be found" when required in another namespace. But if I run cider-load-buffer in the config namespace, it works fine. The config namespace is included in the same directory as the other files (which work normally) and appears to have no syntax errors. What could cause this?

I'm running this with boot and cider in spacemacs if that matters

Ok, just got a new error. Apparently the config namespace can't compile because of this error:

Caused by java.lang.RuntimeException
   Internal graphics not initialized yet

Figured it out, apparently I was trying to create a javafx before the screen had been initialized, which was causing an intermitten error in the config namespace

Are there any online resources / books that would teach about the underlying architecture of Clojure? I'm looking for things that would help me to understand how Clojure actually works (code compilation/execution, behind the scenes processes, caveats with things like macros, etc.) as opposed to things like syntax and results of running code.

not that i'm aware of

Is there any sort of tutorial/better documentation for building an aether repositiory with pomegrante, as boot and lein do?

Anybody can tell me why is it impossible to define a put method in a defrecord? For instance, this works:

(defprotocol Foo
  (get-file [a b c])

  (put-file [d e f]))

(defrecord Bar []
  Foo
  (get-file [a b c] 1)
  (put-file [d e f] 2)

(defprotocol Foo
  (get-file [a b c])

  (put [d e f]))

(defrecord Bar []
  Foo
  (get-file [a b c] 1)
  (put [d e f] 2)

Maybe it's due to the fact a defrecord is a macro and expands to a put method in itself. Might help : https://gist.github.com/skelter/5091143#file-replsession-clj-L56

That's more or less what I thought were happening. In this case, shouldn't there be a list of "forbidden" words in the documentation? Also, if I try the same trick with the get function - which is defined just about 2 lines below and is part of core.clj - or keySet, not part of core.clj but still defined in the same place - or even putAll, function with the same body as put in the macroexpantion you mentioned in the gist, - no exception gets thrown. Except, of course, for the usual warning for the core function overwrite in case of get:

(defprotocol Foo
  (get [a b c])

  (putt [d e f]))

(defrecord Bar []
  Foo
  (get [a b c] 1)
  (putt [d e f] 2) )
Warning: protocol #'user/Foo is overwriting function get
WARNING: get already refers to: #'clojure.core/get in namespace: user, being replaced by: #'user/get
=>Foo
=>user.Bar
(defprotocol Foo1
  (get [a b c])

  (putAll [d e f]))

(defrecord Bar1 []
  Foo1
  (get [a b c] 1)
  (putAll [d e f] 2) )
=> Foo1
=> user.Bar1

Hi!

so, do I report it as a bug or maybe there's something that I missed and this is documented behaviour?

How can I get the outer tag in enlive where the inner tag matches some selector

I always get the inner tag as return

Found a solution -> its using html/has

Notepad++ 7.5.1 patch for Clojure by modifying Lisp model. https://github.com/linpengcheng/ClojureBoxNpp , autocomplete don't need nrepl or JVM. It's the fastest clojure IDE. welcome to #notepad_plus_plus .

@lincpa how does autocomplete work without jvm or nrepl? Parsing for def and defn?

it uses .ctags config from here - https://github.com/linpengcheng/ClojureBoxNpp/blob/master/Notepad%2B%2B/plugins/.ctags

Pre-build an XML file for all symbols of a project and Dependencies Lisp. XML is placed in Notepad++\plugins\apis

ctags is good approach, but incomplete. In the dynamic environment clojure provides, it is more complete to use jvm.

am i right and this lisp.xml file should be regenerated if I would like to introduce new dependency?

autocomplete isn't uses ctags, ctag.exe is used to jump to define

lisp.xml has 40k+ symbols of jvm and Dependencies. And with the automatic completion of the document based word, it's enough.

It's perfect for reading code and modifing code.

I saw a library for compiling Clojure code to php. it hasn't been touched in 5 years but I'm just always amazed when I google "Clojure to <x>" and see the first hit is a github project

Should I be able to reference a global atom defiend in a cljc file from a clj file?

Are cljc files not supposed to have the same namespace as its clj and cljs counterparts? Perhaps it's just a boot requirement?

I don't think you can have foo.cljc as well as foo.clj

I thought I had done just that in the past, but I guess now.

Thanks

I find myself writing (into {} (map (fn [[k v]] ...) m)) a lot; is there a standard lib function for this?

(mapping over a map)

to be more specific, mapping over the values of a map

Ah, I found https://clojure.github.io/algo.generic/clojure.algo.generic.functor-api.html#clojure.algo.generic.functor/fmap

no, but one small improvement is to take m out of the map call and make it a separate arg

@hmaurer that is not part of the standard lib

is it?

@tanzoniteblack yeah it’s not indeed. There doesn’t seem to be anything like that part of the std lib 😞

https://github.com/clojure/algo.generic/blob/master/src/main/clojure/clojure/algo/generic/functor.clj#L33

generally, I just do this by using reduce-kv and creating a new map (which is what you're doing anyways); i.e.

(reduce-kv (fn [m k v] (assoc m (my-fn k) v) {} m)

you could of course always do it with specter as well

https://github.com/nathanmarz/specter

@tanzoniteblack oh I see. I had written a reduce version but thought map would be cleaner

map is faster as well

couldn't you easily walk this?

or would that descend into vals and that's not what you want?

(into {} (map f) arg) is arguably more idiomatic now

spectre looks neat

@dpsutton yeah I don’t want to descend into vals

👍

walking is likely the slowest solution, and does weird things potentially, if you have maps in the values of the map

@matthavener I should read about transducers then!

specter is the highest performance by quite a bit, up to 65% faster than reduce-kv

from benchmark: https://gist.github.com/nathanmarz/b7c612b417647db80b9eaab618ff8d83

equally as important specter doesn't change sorted maps into unsorted maps

wow, into with a transducer is much slower than i expected

into with a transducer is great for sequences, not so much for maps

since wrapping key/value pairs in vectors adds a ton of overhead

is it all the intermediate 2-tuples?

makes sense

here's a more up to date version of that benchmark with more cases:

Benchmark: transform values of a small map (500000 iterations)

Avg(ms)		vs best		Code
62.560 		 1.00 		 (transform MAP-VALS inc data)
88.289 		 1.41 		 (map-vals-map-iterable data inc)
89.023 		 1.42 		 (reduce-kv (fn [m k v] (assoc m k (inc v))) {} data)
96.205 		 1.54 		 (persistent! (reduce-kv (fn [m k v] (assoc! m k (inc v))) (transient {}) data))
125.09 		 2.00 		 (map-vals-map-iterable-transient data inc)
126.38 		 2.02 		 (reduce-kv (fn [m k v] (assoc m k (inc v))) (empty data) data)
262.15 		 4.19 		 (into {} (map (fn [e] [(key e) (inc (val e))])) data)
376.26 		 6.01 		 (zipmap (keys data) (map inc (vals data)))
424.99 		 6.79 		 (into {} (for [[k v] data] [k (inc v)]))
429.51 		 6.87 		 (into {} (map (fn [e] [(key e) (inc (val e))]) data))
437.50 		 6.99 		 (transform [ALL LAST] inc data)

********************************

Benchmark: transform values of large map (600 iterations)

Avg(ms)		vs best		Code
84.023 		 1.00 		 (persistent! (reduce-kv (fn [m k v] (assoc! m k (inc v))) (transient clojure.lang.PersistentHashMap/EMPTY) data))
86.743 		 1.03 		 (transform MAP-VALS inc data)
95.225 		 1.13 		 (persistent! (reduce-kv (fn [m k v] (assoc! m k (inc v))) (transient {}) data))
101.18 		 1.20 		 (reduce-kv (fn [m k v] (assoc m k (inc v))) {} data)
125.21 		 1.49 		 (reduce-kv (fn [m k v] (assoc m k (inc v))) (empty data) data)
149.87 		 1.78 		 (into {} (map (fn [e] [(key e) (inc (val e))])) data)
168.20 		 2.00 		 (map-vals-map-iterable-transient data inc)
185.75 		 2.21 		 (map-vals-map-iterable data inc)
196.57 		 2.34 		 (transform [ALL LAST] inc data)
214.91 		 2.56 		 (zipmap (keys data) (map inc (vals data)))
218.59 		 2.60 		 (into {} (for [[k v] data] [k (inc v)]))
219.78 		 2.62 		 (into {} (map (fn [e] [(key e) (inc (val e))]) data))

so 4x faster than transducers for small maps, 80% faster for large maps

@nathanmarz are there similarities between spectre navigators and haskell-style lenses?

yes, though I'm not familiar enough with haskell lenses to give a detailed answer

haskell splits its navigator-equivalents into multiple types (lens, traversal), while specter has a single interface for all navigators

out of curiosity, did you base Spectre on research? or is it more of a practical implementation of what felt nice to work with?

oh, I see 🙂

it's the result of unifying a crazy amount of use cases in the problem domain

starting with basic compound use cases and evolving from there

a lot of my personal work involves recursive DAG's, so making really involved transformations on those elegant guided the development of specter a lot

Having trouble with lazy sequences & would love some help from a more experienced clojurian: https://stackoverflow.com/questions/45970034

@chalcidfly that can’t be lazy because there’s no step where you can use the head but not evaluate the tail

it does a direct self recursion, and to get the n+1 element, you need to do the recursive call

(lazy-seq …) should pretty much always have a call to cons inside - or something that lets you return the next item of the list without recurring

@noisesmith I see… what about appending to a vector?

vectors are never lazy

oh, gotcha.

also conj isn’t lazy, because it needs to check the type of its first arg

what about appending to a list then?

you can’t append to a list without realizing the whole thing - though you can do concat but wanting to do that recursively usually means you are making a mistake

the standard pattern is (lazy-seq (cons (make-next arg) (make-rest other args))

Oh, I see.

hmmmm…. gotta rethink this one

thanks for the help!

so in your case it would probably be something like (lazy-seq (cons (f val (first coll)) (red val (rest coll)))

it’s just a question of pulling the next item out of the recursive call so it can be used immediately without the recursion happening

I think you’ll need to make other small changes to make that work - but the code will get simpler

updated with an answer