Clojurians Log v2

Would using def as a mutation mechanism cause any compiler or execution anomally ? i.e. (def a [1 2 3 4]), and then later on mutating a with (def a (conj a 5))

not sure what you mean by anomaly. would the following work for your use case?

(def a (atom [1 2 3 4]))

;; later on
(swap! a conj 5)

I'm sure that would work. It is more idiomatic for sure.

def is thread safe, swap! is safer because it retries, to answer your question, no there are no compiler or execution anomolies caused by def (other than side effects inside def, which run while compiling, a common gotcha for making packages for deployment)

so for example someone runs $ lein uberjar and it never returns because it starts a server or something while compiling your code

@noisesmith that’s gotta be one of the leading beginner gotchas 🙂 I remember running into that back in 2013 when I first tried making an uberjar

Are there any good books, guides, videos or other resources that focus on teaching the ecosystem surrounding Clojure? As someone who has barely touched Java I feel a lot more confused about maven and POM and deps and uberjars and nREPL etc etc than about LISP syntax or functional programming. I feel like a lot of the literature is aimed at people who are already familiar with the Java landscape, or it doesn’t touch the practicalities of running and deploying Clojure at all. I’ve read two Clojure books and I still feel like I don’t really understand how the REPL interaction with a running program works, or how I am supposed to deploy a Clojure program in a somewhat professional manner. In some ways I feel like starting out with Cursive has hampered my learning as the IntelliJ environment sets up a lot of facilities for me.

a few random questions: 1) does (last (take 1000 (some-infinite-lazy-seq)) end up being the same as (nth some-infinite-lazy-seq 1000) because of the laziness? or do the extra 999 from take occupy some space/time? 2) if I annotate values with type metadata, like ^long, do I need to annotate each fn that those values will travel through in order to take advantage of any potential performance gains? or just the place where they initially come into be? like if I annotate the return from a fn, do I also need to annotate functions where I'm passing that result or is just one place enough? 3) is there an idiomatic value to use for the placeholder in as->? I've been using _ though I see a lot of $. I'll probably keep using _ because I like it, but just wondering if there's convention there

Is there a way to update/replace value in lazy seq? All my attempts have failed to complains that seq is not an associative structure. When I change my lazy seq to a vector then I can do it with (assoc my-seq 1 new-element)

I don't know of a single function for this, but it can be achieved with take and nthrest:

(defn update-seq [target i elem]
  (let [pre (take i target)
        post (nthrest target (inc i))]
    (concat pre [elem] post)))

user=> (take 10 (update-seq (range) 5 "hello"))
(0 1 2 3 4 "hello" 6 7 8 9)

Thanks, Balint. I wonder is there some reason why core functions doesn’t support this out of the box

3) replacing unused function/collection elements with _ is idiomatic. I see people use $ a lot for as->. I can't see anything in https://guide.clojure.style/

I don't think anyone will come after you with pitch forks either way!

Yeah, like @slgeorge says, _ would indicate that something that is unused, so other people reading your code might get confused.

I just use $, personally

There's replace if you really to to "update/replace value"

Regarding 1, while far from comprehensive, this should give you an indication:

(dotimes [_ 5] (time (nth (repeat 1) 1000)))
"Elapsed time: 0.095773 msecs"
"Elapsed time: 0.069648 msecs"
"Elapsed time: 0.071448 msecs"
"Elapsed time: 0.068614 msecs"
"Elapsed time: 0.076651 msecs"
=> nil
(dotimes [_ 5] (time (last (take 1000 (repeat 1)))))
"Elapsed time: 0.243615 msecs"
"Elapsed time: 0.217264 msecs"
"Elapsed time: 0.208162 msecs"
"Elapsed time: 0.213417 msecs"
"Elapsed time: 0.206169 msecs"
=> nil

I'm not sure how nth works with lazy sequences, and I'm a Clojure beginner. But I would assume that last+take both have to traverse the elements in some way. nth should only have to do that once in this scenario.

If you expand the example to take the 10,000nd element the performance difference is a lot bigger in favour of nth.

Leiningen question: using lein uberjar to create a standalone jar for deployment, but for some reason it's taking ages. It takes 20min to end up with an uberjar of only 140M (So not exactly massive?). Any directions on how to improve this? Should I look into leiningen, or are jvm options to blame, or .... ? I have no proper Java experience, so often feel in the dark with these kind of Clojure ecosystem problems.

Are you sure you aren't doing any "real work" when compiling? In particular, if you use AOT compilation all the top level vars are evaluated. Sometimes this might mean that connections to external resources (like DBs) are established and so on.

Hi all, I've written a function called map-in that lets you transform a single element of a (possibly) nested structure like this: (defn map-in [m ks f] (assoc-in m ks (f (get-in m ks)))) so let's say I want to increment the age of the first person in the list: ==>(map-in [{:name "John" :age 35},{:name "Sue" :age 29}] [0 :age] inc) [{:name "John", :age 36} {:name "Sue", :age 29}] Thing is, I don't want to invent the wheel and I'm sure this must be already in core or some common library, can anyone point me at it?

No top level vars in my code. Also, the class generation part and the non-standalone jar are created in ok times, but the standalone one takes ages. Does this mean a dependency is the culprit or are there other potential reasons?

Vectors are associative, so if you know that m is a vector, you can simply use update-in:

user=> (update-in [{:name "John" :age 35},{:name "Sue" :age 29}] [0 :age] inc)
[{:name "John", :age 36} {:name "Sue", :age 29}]

> if you know that m is a vector Which I guess you're already relying on since you use get-in in your implementation.

Yes thanks update-in is exactly what I was looking for but just couldn't find the right words to search for it. actually m will usually be a map but update-in works with both

Indeed.

Regarding 2: “Once a type hint has been placed on an identifier or expression, the compiler will try to resolve any calls to methods thereupon at compile time. In addition, the compiler will track the use of any return values and infer types for their use and so on, so very few hints are needed to get a fully compile-time resolved series of calls.” https://clojure.org/reference/java_interop#Java%20Interop-Type%20Hints

How do I create a clojure app if clojure -X:new create :name myname/myapp gives me this error? Unqualified function can't be resolved: create

clj -X:new :template app :name myname/myapp is the answer

Which version of the clojure CLI tool do you have installed? You can use clojure --help to check. That command should also work.

I copied the alias directly from here: https://github.com/seancorfield/clj-new#getting-started

One possible reason is you are including the uberjar in itself

Replacing nth value in an immutable list/seq is a slow (linear) op so there is no function for it.

Generally we try to think in terms of whole seq modifications, using map etc anyways

1 - yes they take space to allocate and gc as the take seq nodes (which nth will not) 2 - it depends. If the value is passing through multiple functions, each arg has to be marked as long or it will be converted to a boxed value 3 - don’t use _, but otherwise doesn’t matter

Thanks Alex, that makes sense

where I can find documentation for running main function? https://github.com/bigos/report-generation/blob/main/src/cls/report_generation.clj I get all sorts of errors when I try examples found on the web

https://clojure.org/guides/deps_and_cli https://clojure.org/reference/deps_and_cli clj -M -m cls.report-generation

I would never guess reading the output of clj --help

thank you very much, I will try now]

clj -M -m cls.report-generation Syntax error compiling at (cls/report_generation.clj:12:3). Unable to resolve symbol: simple-body-page in this context Full report at: /tmp/clojure-2027952924787189784.edn

There's a bug, move the routes after the 2 next fns used.

still the same problem

thank you very much for helping me with this frustrating problem

ah, I see now routes are twice there, just remove the first defroutes

Hurray, the browser says hello world. thank you for your patience and help!

@jumar I tested this but realised that it will replace elements by comparing the actual value but not by index. So if I have several elements with the same value I’ll be replacing them all

I think generally if you get to the point of asking this question, you are probably going about something the wrong way

Agree. I ran into these situations while I’m solving advent of code problems. Now the easiest fix for the solution would have required me to just replace an element in a lazy-seq. I haven’t run into this before and wanted to confirm if this is even possible 🙂

try using some kind of linter that integrates with your editor. I found it difficult to set up but once it's working it's so much easier to find problems

Sorry to ping you directly @alexmiller, but I'm curious about Clojure Applied. Is it still mostly relevant and useful stuff, or have parts of it gotten outdated enough that you'd recommend something else? Or just some complementary reading? It's hard to know how much five years really is for a book when you're new to a community. And I figured you'd be the best source to ask here...

I'd say it's still 80% relevant

I am starting to look at 2nd edition, but it's likely to be at least a year before such a thing exists

Great! I'll read it with that in mind. Thanks a lot for answering. I'm on a Clojure reading binge at the moment (as most of my current free time is reading in bed while my daughter is sleeping, can't actually program there...).

we call that "hammock time" :)

Yes, apart from reading I'm also looking at the massive backlog of talks, Hammock Driven Development being the one I just started.

Surprisingly I've found that reading about or formulating a problem early in the day and then having it simmer in my mind while I work, pick up groceries and so on usually lets me discard at least one or two false starts that would waste a few hours of coding...

for sure

i find that some of the pretty printing doesn't return a value that can be read/evaluated. specifically, vectors become lists with a literal (). i often want to replace the data with a transformed version, and iterate on that. are there strategies or other pretty printing folks know of?

if you quote those, you can read them as data

with the repl... it feels like this should be or could be programmatic

I don't find it to be so, depends on how you're using it

if you def the result (or use *1 etc) you are still working on the data

i just want to point out that your specific complaint doesn't seem true. Vectors do not become lists. (clojure.pprint/pprint [1 2]) yields [1 2] not (1 2)

I'm assuming he's seeing things like (map inc [1 2 3])

@dpsutton it's not consistent

applying a seq function to a vector will return a seq that prints as a list

it is in fact very consistent if you understand the model :)

https://clojure.org/guides/faq#seqs_vs_colls

maybe it's as simple as switching to mapv

The problem is, you start with a vector, but then are using sequence functions on it. Those will automatically convert the vector into a sequence and from that point on, you have a sequence which prints as a list

Instead, you need to use vector functions, those will keep things as a vector. The downside of this is that there's a lot less of them. You have mapv and filterv and that's about it

Another approach in those cases where you really care about the type of the collections is to use transducers instead

There's a lot more transducer functions then there are vector functions (though still not as many as their are sequence functions)

With transducers, you just tell it what type you want the resulting transformation to be in

For example this:

(->> [1 2 3 4 5]
     (filter odd?)
     (map inc)
     (take 5))

(into []
   (comp (filter odd?)
         (map inc)
         (take 5))
  [1 2 3 4 5])

And this is an example where you could have used filterv and mapv, but there is no takev, so ya transducers to the rescue!

very slick, this should prove helpful to me

> vectors become lists with a literal () this is not true, you are changing your data type somewhere or are misusing the term "vector"

does using into with a transducer/xform give runtime benefits over doing it like the first example:

(->> [1 2 3 4 5]
     (filter odd?)
     (map inc)
     (take 5)
     (into []))

:thumbsup: thanks!

Yes it does. Using transducers will be the fastest and use the less memory. Using sequence will be faster than using vector functions, at least for large collections, maybe not for small ones. But it will use more memory. Using vector functions will be slowest, especially for large collections, might be faster than sequence for small ones, won't be faster than transducers though.

The way to think of this is that, with vector functions like filterv and mapv, you are looping over the whole collection at every step. So first filterv everything, then mapv everything. So you're unnecessarily looping more than once over the collection. With transducer, you are looping only once, and applying the full chain of transformation each iteration. So you loop only once of each element, and filter map and take in one go. With sequence, you will be looping only once on the collection as well, like transducer, but after each iteration, you will create a remainder sequence, the creation of this intermediate sequence after each iteration is why it is slower than transducer. But this is also what makes it lazy, as the remainder sequence won't start the next iteration immediately, it'll wait for someone to request the next element from it to do so. Finally, calling vec after a sequence will cause a second loop, so the sequence chain will loop once and filter, map and take on each iteration (creating an intermediate sequence at each step), and finally when that is done, vec will loop over the result one last time to convert the sequence back into a vector. That is one extra loop over using transducers directly.