you didn't ask but if you already know how to program then Getting Clojure is an amazing book for learning Clojure

Thanks. I’ll check it out.

There are lots of great resources for learning Clojure https://clojure.org/community/resources

and also @U05254DQM puts out this very excellent resource https://practical.li

Dereferences the atom, which contains a delay that also needs to be deferenced.

i'm not sure why there is a delay inside an atom though

it's actually covered in the integrant readme

Yep. This section here, @U025AG2H55F https://github.com/weavejester/integrant#suspending-and-resuming

OK! thanks

@U06BE1L6T Thanks for your response! How can we make a single function separated ?

I'm not sure what you're asking for O:-)

I have a function where I am calling from webservice,, So separating memoize function would be difficult in my case

@popeyepwr I think there's some confusion here. I was talking about the case when you are running the REPL and working on the application. To see how it works, you can do as I suggested, that is evaluate the whole code block only once and then try to call (my-func-memo a) , perhaps in the REPL, a few times. I'm not sure what you mean by "separating memoize function would be difficult in my case" but you definitely don't need to move it to another namespace. You can simply keep it as it is now

I think your trouble might be that you have only learned how to evaluate the whole buffer/file/namespace and the individual forms (like defn)

@U06BE1L6T sorry for the late response , Yeh I understood how it behaves in repl, But how about production code where it calls the function again and again on refresh

What do you mean by "refresh"? There's typically no such thing in the production code.

page refresh (page load)

Ah, I see. Sure, that's just calling the function. So the first time it will do the actual calculation, after that it will use the cached (memoized) value.

it evaluates all the forms one-by-one.

@popeyepwr — did you solve your issue?

Have to troubleshoot some more, since I am playing with production code

Can you elaborate? Do you want to stop under certain conditions?

nope, I do not want second function to called,

Direct answer: You can create an exception object and analyze its stacktrace to see if there are multiple calls to some function. But i would not advise you to do that. Change the function instead

To clarify: is the second function defined inside the lexical scope of the first and subsequently called by the first? Or is it just called?

I read in some doc, that we can make use of promise ,

but I do not remember which is that function, like once promise object is already derefered, thenit would not call that function again, I lost that doc

I’m not sure if I understand the intent, but I can think of three ways to avoid evaluating the second function without things becoming too “magical”: • The arguments passed into the first function somehow affects if the second should run, so for example if you pass in a counter during recursion then it only runs when the counter equals 1 (or just not at all). • If the goal is to run the function only once, then store the evaluated value in an atom and during recursion check if the atom has changed from whatever the default value is • Use a dynamic var to turn evaluation on or off depending on the context

(def ^:dynamic *skip-evaluation* false)
(defn second-worker []
  (prn "I do things!"))

(defn first-worker [x]
  (when-not *skip-evaluation*
    (reset! worker-result (second-worker)))
  (prn "Loop number " x)
  (inc x))

(first-worker 0)

(binding [*skip-evaluation* true]
  (loop [x 0]
    (if (> x 5)
      x
      (recur (first-worker x)))))

@popeyepwr — can you share function definition where promise is created?

Sorry! I saw that doc some days back! will try to find it out

Thread necromancy! I just stumbled upon the delay-function which might help you achieve what you’re expecting: https://clojuredocs.org/clojure.core/delay

(you have to define the delay outside the function body and “deref” it to make sure it runs once)

(defn printer-error [s]
  (-> (filter #(> (int %) 109) s)
      count
      (str "/" (count s)))) 

Your intuition was spot on. This is the best, by far:

(defn printer-error [s]
  (let [total-invalid-chars (count (filter #(> (int %) 109) s))]
    (str total-invalid-chars "/" (count s))))

concur with @U031CHTGX1T

(Personally: I'd let-bind invalid-chars rather than their count, then (str (count invalid-chars) "/" (count s)) )

docstrings are always useful 🍰

My point was: Use let instead of trying to thread it all together

@U031CHTGX1T it was a Kata from CodeWars, just to practice some Clojure: https://www.codewars.com/kata/56541980fa08ab47a0000040/train/clojure

@U01RL1YV4P7 your code work perfectly! I though I need to convert to a seq before send into filter function

@U050ECB92 Agree with the count outside would be better in that solution 😄

(->> (-> (clojure.string/join " " [ "Hello." "How" "are" "you?" "I" "am" "fine."])
         (clojure.string/split #"(?<=\.)|(?<=\?)|(?<=\!)"))
     (mapv clojure.string/trim))
=> ["Hello." "How are you?" "I am fine."]

(defn group-words [words]
  (let [n (atom 0)]
    (partition-by (fn [w]
                   (let [i @n]
                    (when (re-matches #".*[.?!]$" w)
                      (swap! n inc))
                    i))
                  words)))

(group-words ["Hello." "How" "are" "you?" "I" "am" "fine."])
; => (("Hello.") ("How" "are" "you?") ("I" "am" "fine."))

(->> words group-words (mapv (partial clojure.string/join " ")))
; => ["Hello." "How are you?" "I am fine."]

partition-by and mapv both look like good solutions. Thanks.

The first suggestion can be simplified by including space(s) after the lookbehind:

(-> (clojure.string/join " " test-text)
    (clojure.string/split  #"(?<=[.?!]) +"))
;; => ["Hello." "How are you?" "I am fine."]

Another pretty elegant solution involves spec:

(require '[clojure.spec.alpha :as s])
(defn stop? [w] (re-matches #".*[.?!]" w))
(s/def ::sentence (s/cat :words (s/* (complement stop?)) :stop stop?))

(s/conform (s/+ ::sentence) ["Hello." "How" "are" "you?" "I" "am" "fine."])
; => [{:stop "Hello."} {:words ["How" "are"], :stop "you?"} {:words ["I" "am"], :stop "fine."}]

(->> ["Hello." "How" "are" "you?" "I" "am" "fine."]
     (s/conform (s/+ ::sentence))
     (map (fn [{:keys [words stop] :or {words []}}]
            (conj words stop)))
     (map (partial str/join " ")))
; => ("Hello." "How are you?" "I am fine.")

\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

The path to the tlsCAFile is encoded as I have it for the Node.js application.