I'm reading Chapter 6 from Joy of Clojure and in the section about laziness they claim that next is "less lazy" and should print three dots in the example below - but for me it prints also only two dots. Is that something that has been changed in a more recent version of Clojure?

;; rest vs. next (p. 126)
(def very-lazy (-> (iterate #(do (print \.) (inc %)) 1)
                   rest rest rest))
;;=> prints two dots ..


(def less-lazy (-> (iterate #(do (print \.) (inc %)) 1)
                   next next next))
;;=> prints two dots too?!

iterate has been rewritten since JoC was written

it's now both seq and self-reducible and written in Java, so all of the details are different

changed in 1.7

Interesting, thanks!

the point is still generally valid :)

Yeah, I think it's visible here:

(defn simple-range [i limit]
  (lazy-seq
   ;; nil returned by when will terminate the range construction
   (when (< i limit)
     (print ".")
     (cons i (simple-range (inc i) limit)))))
;; prints 3 dots
(def rrr (rest (rest (rest (simple-range 1 10)))))
;; prints 4 dots
(def nnn (next (next (next (simple-range 1 10)))))

Quick questions on atoms — if I understood the thing correctly the way they should be used is by dereferencing them once at the beginning of where they're used — and not dereference them every single time that is needed, in order to have the same value for the entire time of the computation.

…because dereferencing it every single time that is needed might ultimately give two different values

that's correct, they're mutable, so they can change from under you.

but if I dereference them once, at the beginning of my computation and save the value using a let binding

I am "protected" — the box can point to something else, the value I dereferenced is immutable

if you store an immutable value in the atom, yes

Ok perfect, that makes completely sense. Thanks @borkdude

@vincenz.chianese Note that for updating atoms you generally want to use swap!, if the update function references the current value

e.g. don't do this:

(def x (atom 1))
(reset! x (inc @x))

(swap! x inc)

@borkdude Oh yeah for sure, I think I've understood the semantic of swap! and reset!

I was just having some doubts on how the mechanism would make sure that there are no race conditions and weird stuff in multithreads; now that I understood the thing (separate the value from its pointer) it's totally clear.

Hey there.

I am quite new to Clojure and I cannot really grasp why why str/join is ignoring the last argument here. bb '(-> "some str" (#(str/split %1 #" ")) (str/join "-"))'

I understand there are two signatures for clojure.string/join function but I can’t get why the extra argument is ignored here. Using macro for anonymous function of course solves the issue, but shouldn’t this work like this, too. If not - why not?

The -> macro is going to to thread the return values through in the first argument position. The line you have there ends up compiling to: (str/join (#(str/split %1 #" ") "some str") "-") . I think what you'd like is something like this: (str/join "-" (str/split "some str" #" ")).

Does that clear things up?

As you're new to the language, one of the things worth knowing about Clojure is that many of the core functions take a "garbage in, garbage out" approach. So even though your original form evaluates to "-", the call itself has the arguments out-of-order – (str/join ["some" "str"] "-")

Yeah, I was sure I was using thread-last macro, many thanks. 🙂

Is it possible to use System/getEnv in edn file?

@ad399 When I'm trying to figure stuff out I usually use the macroexpand-all function from clojure.walk to figure out what is the final form. This should be helpful to debug more issues in the future:

(use 'clojure.walk)
(macroexpand-all '(-> "some str" (#(str/split %1 #" ")) (str/join "-"))

(str/join ((fn* [p1__9737#] (str/split p1__9737# #" ")) "some str") "-")

@mitesh This is very nice, thank you.

Are there any suggestions or improvements?

(defn take-sorted-by [c n f]
    (let [m ^TreeMap (TreeMap.)
          m-size (volatile! 0)
          m-add (fn [k v] (if-let [a ^ArrayList (.get m k)]
                            (.add ^ArrayList a v)
                            (.put ^TreeMap m k (doto (ArrayList.) (.add v)))))
          m-sub (fn [k] (let [a ^ArrayList (.get m k)
                              size ^int (.size a)]
                          (.remove a (dec size)) ;; (dec size) have to be int type!
                          (when (.isEmpty ^ArrayList a)
                            (.remove ^TreeMap m k))))]
      (doseq [v c]
        (let [k (f v)]
          (if (< @m-size n)
            (do
              (m-add k v)
              (vswap! m-size inc))
            (let [max-key (.lastKey ^TreeMap m)]
              (when (< k max-key)
                (m-sub max-key)
                (m-add k v))))))
      (->> m vals (apply concat))))

  (defn take-sorted-by-naive [c n f] (->> c (sort-by f) (take n)))

  (let [c (range 100000000)
        n 10
        f #(rem % 15000000)]
    ;; (-> (take-sorted-by-naive c n f) prn time) bad idea, Execution error (OutOfMemoryError)
    (-> (take-sorted-by c n f) prn time))

(0 15000000 30000000 45000000 60000000 75000000 90000000 1 15000001 30000001)
"Elapsed time: 2268.525789 msecs"

yep, ofc (:import [java.util TreeMap ArrayList])

In cases where you need to accumulate a result across a sequence, and check for an end condition after each new item, are there any general guidelines on when to prefer loop/recur vs reduce/reduced? It seems like it might be best to prefer reduce if that is sufficient, since it's higher level. But on the other hand I haven't seen that as often and there might be more nuance involved there?

Here’s a nice little write up on it https://groups.google.com/g/clojure/c/Q9KrgqyToIo/m/0MqKg2WIAwAJ

I tend to use reduce when there's just one accumulator of sorts. loop for everything else that can't be expressed with other higher-order functions.

2 accumulators = one accumulator 🙂

within a given namespace, is it possible to see which vars aren't defined in it? i mean, which vars are defined elsewhere and required/imported in?

i have a habit of writing :refer :all, and i want to step through my project's namespaces and convert those :refer :all lines into :refer [specific-var] lines

and it's a slow process to change it to be (:require ... [other.namespace]) and then compile and see what's failed, and then add them in one at a time

you might give https://github.com/technomancy/slamhound a try

oh that's cool as heck

thank you so much

exactly what i was looking for

@nbtheduke clj-kondo can also help with this, provided you have linted all your sources so it can infer where vars are coming from in case of refer all

Is there a way to get a collection's item by index and also remove it from the collection, all in one shot?

Essentially, something better than this:

Ideally I would like both

The new collection and the extracted item

vectors aren’t great for that type of thing, depending on what you’re doing maybe you could use an ArrayList instead?

Well essentially I'd like something like const [elem, newVector] = removeElement(originalVector, index);

I'm new to Clojure and my knowledge of Java is literally -1

not a problem! if you can provide some more context I might be able to point you in the right direction

Well again, I'm looking for a built-in function (if any) to do this:

user=> (remove-collection-index [9 8 7 6 5 4 3 2 1 0] 3) [6 (9 8 7 5 4 3 2 1 0)]

there isn't a function to do this, and I would encourage you to structure your data in a way that you don't need it

agree, that’s why I was asking for more context 🙂

All right! Thanks for the help. I'm trying to get some proficiency in Clojure and I'm trying to implement the "Game of Pure Strategy" game.

In the game, there's a step where I need to draw an element from a deck and then remove it (the removal is part of the construction of the "next state")

This is the initialState I start with and then I have a function gameStep that takes such state and provides the new one

I need to draw a card from all the decks, do a comparison and then call the gameStep again (which has a guard clause of course, and is (= 0 (count (:bountyDeck currentState)

If there'a better way — I'm all for it!

one idea from the top of my head is to model the deck as a map from index to card

then the “get and remove” would be as easy as calling (dissoc deck index)

{:1 1}

Something like this?

yeah

:thinking_face: I'm curios now, why is it ok for maps to get and remove and not so ok for vectors?

because maps support removal by key and vectors don't

Ah ok — so the idea is not that bad, I'm just using the bad data structure if I'm following

exactly :thumbsup:

but I'm on the same situation now?

I get a new map, but not the removed value — I'd still need to lookup the element value manually

do (get testMap :1) and store that before you dissoc

Got it, and I'm assuming there's no way to do that in one shot with a built in function

Wouldn't a set be even better?

I don’t think so, no

a set is not ordered, I assume the deck is?

No, I do not care about the order

then set is better, yes! sets use disj instead of dissoc, fyi

Ok, let's then!

Ok I got it working. It's terrible, I know, but it's a start. I'll go from there, thanks!

First lesson learned: accessing nested maps can be a pain, so better keep data structures as simple as possible

looks good, definitely on the right track! :thumbsup:

@vincenz.chianese If you want to remove by index and get an item at the same time, you can always use juxt

(juxt :1 #(dissoc % :1))

will return a vector that is basically

[(:1 ds) (dissoc ds :1)]

when called on whatever structure

Oh interesting

juxt is generally pretty useful if you want to do things "all in one shot" (logically, there might be multiple passes over data)

I can see! Calls multiple functions on the same arg right?

(let [[value new-coll] ((juxt #(nth % 3) #(remove (partial = 3) %)) collection)])

and returns the result in a vector

That’s weird right?

user=> (map #(doto % println) [1 2 3])
(1
2
3
1 2 3)

What's weird about it?

Shouldn’t it be outputting?

1
2
3
(1 2 3)

Why?

The side effect should trigger before the result is returned for printing right?

map produces a lazy seq, so the REPL starts to print a sequence ( then it has to realize the first chunk of it -- which causes the function to be called on three elements -- and then it can print that chunk.

When you mix laziness and side-effects, you should expect interleaving 🙂

Try (map #(doto % println) (range 40)) and you'll see chunking in action.

I suppose that makes sense. Sounds like I’m picking a terrible test case to showcase Clojure’s ability to map over vectors, lists, and hash-maps.

It'll print ( then 0 to 31 (from the println) then the result of the first chunk -- a line with 0 1 2 3 .. 31 -- then it'll print 32 up to 39 (from the println) then the next chunk of the result -- a line with 32 33 .. 39 and the )

I’ll just switch to a pure function

I’ll try it

Never mix side-effects and laziness!

If you use mapv it is eager and you won't get interleaving.

(but, yes, a pure function would be a better demonstration -- otherwise you have to explain laziness and chunking!)

I’m surprised I haven’t run into that before, but thanks for explaining it.

Although I suppose I usually print the seq or use a do-seq for that