I'm using EMACS/cider and I've spec'd and instrumented a bunch of functions. The argument to a function is failing to meet the spec and cider is giving me a stacktrace. Nowehere in the stacktrace does it identify where in the code the spec failure is and that makes me think I must be doing something wrong. Symptoms:

I have a line that says: Spec: #object[clojure.spec.alpha$every_impl$reify__2254 0x46fce19 "clojure.spec.alpha$every_impl$reify__2254@46fce19"]

I have a stack trace that identifies: cityevolver.clj: 91 cityevolver/evaluate-placement-list

As the last function I wrote. It calls 3 other functions and one of them has malformed arguments

So I know that an argument has failed a spec but I get the impression something is wrong because there is no line saying "... and the spec was for arguments to [function-which-was-spec'd]"

Any hints?

That's interesting. It may actually be related to new clojure errror reporting. But you can try to inspect the exception manually in the REPL:

*e

There you should see where it's coming from

Cheers

what is the simplest way to change this [30.723457672119142 36.869895291987106] to [30.7234 36.8698]

Hi everyone, I am new to Clojure (and emacs) and I am facing this challenge. I am following the instructions in the book/site Clojure for the brave and true and I can't start the REPL in emacs. when i do M-x cider-jack-in i get

error in process sentinel: could not start nREPL server: no Java runtime present, requesting install.

I have another problem "4.455" to decimal 4.455 and "3.14" to 3.14 to do this my function became very long do you know short way?

Hi guys, I'm an iOS developer trying to learn Clojure. I have no experience with the Java world or web development. This makes it quite difficult for me to learn Clojure and make use of it as I often improve best through pet projects. Tbh I feel kinda lost rn. Can anyone recommend me a learning path or point me to the right direction? Really appreciate your help!

app:calculator.core=> (= js/Number (type 1))
true
app:calculator.core=> (instance? js/Number 1)
false

Never mind. I guess that's a JavaScript thing. 1 instanceof Number is also false.

I believe instanceof checks the prototype

and 1 is a primitive

In ClojureScript, you can (macroexpand '(number? 1)) to see what it does

Hi all, I am getting started with clojure and working through the brave and true book. In the exercises for chapter 10 (at the bottom of https://www.braveclojure.com/zombie-metaphysics/), there is one where I need to get several random quotes from in parallel and save word counts in an atom. I solved it, but I don't think my code is very idiomatic and I am trying to understand how to solve it better, can you please look at my solution and tell me how it could be improved? https://gist.github.com/passick/4d100029c217c2c9e80e8cd7f9990118

In particular, that stuff with doall and the way I create several futures seem fishy to me. Is there a better way to do it?

Since you are using map/`doall` purely for side-effects, run! is probably what you want instead.

But look at repeatedly for invoking a no-argument (side-effecting) function a fixed number of times (instead of the first map over range)

And instead of #(if %1 (inc %1) 1) you could use (fnil inc 0)

fnil adapts a function such that if the argument(s) are nil, the replacement value is used instead before the function is called.

So something like (run! deref (repeatedly n-quotes (fn [] (future (process-quote ,,,)))))

Ooh, didn’t find run! and fnil, thanks! I have tried using repeatedly at first, but couldn’t make it work with future, not sure why.

Thank you, will try again!

But wouldn’t (run! deref (repeatedly …)) create a future and dereference it immediately?

So the futures will be run in sequence?

I'd have to check whether repeatedly is chunked or not. If you want real parallelization, sequences are not the way to do it in the first place.

Doesn't look chunked... so, yeah, that might well produce sequential execution...

If you want control over the level of concurrency, you pretty much have to drop down to Java and use executors etc.

I just want the tasks to be executed in parallel, that sounds like a basic thing.

I think my solution does it, no?

well, pmapfor quick and dirty

With the caveat that pmap is almost never what you want in production code 🙂

hence the "quick and dirty" :)

Yes, looks like (doall (pmap...)) should do it. The exercise asks for futures explicitly, though.

Since you don't need the result back, you could use dorun (which doall uses under the hood, but then returns the original collection).

I suspect Brave&True is just expecting something simple like you had in your Gist -- but it's not idiomatic nor really "in parallel" so it's all a bit hand-wavey 🙂

I’m currently trying to create my first macro and still have some troubles…I’m trying to create a macro where I can define some bindings which are directories that should be removed in the end. The idea is basically to have a temporary directory, do something, and be sure that the directory is deleted afterwards. I tried to do it similar to the with-open macro since it seemed similar. Here is what I currently have:

(defmacro remove-after
  [bindings & body]
  (cond
    (= (count bindings) 0) `(do ~@body)
    (symbol? (bindings 0)) `(let ~(subvec bindings 0 2)
                              (try
                                (remove-after ~(subvec bindings 2) ~@body)
                                (finally
                                  (let [dir ~(io/as-file (bindings 0))]
                                    (doseq [file (file-seq dir)
                                            :when (.isFile file)]
                                      (io/delete-file file))
                                    (io/delete-file dir)))))))

No implementation of method: :as-file of protocol: #' found for class: clojure.lang.Symbol

@christian.paling A general bit of advice for writing macros is: try to write a function to do most of it first, and then write the macro as a wrapper around calling that function. That will help remove a lot of the problems.

Thanks, yes that sounds like it would make matters more easier

In the above, you're trying to introduce local bindings dir and file and those will be resolved to fully-qualified symbols which won't be correct. Use dir# and file# instead.

They will be resolved to fully-qualified symbols because of the ` right ?

you could start with f where f takes a function g and invokes g with a single argument which is a directory, and deletes the directory after g finishes executing

And I think you want (io/as-file ~(bindings 0)) instead of ~(io/as-file ,,,) at a glance...

Because (bindings 0) is a Symbol (as its value) so you'd end up calling io/as-file on (essentially) 'foo instead of the value of foo

@hiredman Yes that’s true, that would be easier. I just liked the way with-open is doing it, and wanted to copy 😄

given the above approach you can write a simpler macro

(with-temp-files [a] b) =macro expands to=> (f (fn [a] b))

you are making it hard on yourself by combing the syntax rewriting and the actual computation in the macro

you can capture the computation you want as a function, and then simply use the macro to rewrite the syntax you want in to a call to that function

@hiredman and in the fn [a] the a would basically be all symbols of the a vector that was passed to the with-temp-files vector ?

and f would call the inner function with the values of these symbols ?

it depends how you implement it

no

(defn f [g] (let [tmp ...] (try (g tmp) (finally (delete tmp)))))

you have two things going on, something producing a value (the tmp directory) and something binding that value to a name

in your macro you are juggling both of those

the f function is only resposible for producing the value, the binding of the value to a name is taken care of via the construct clojure already has for that, a function

so something like (with-temp-files [a b] c) might expand to (f (fn [a] (f (fn [b] c ))))

Alright, I see ! Still have to wrap my head around “thinking one level higher up”. Your approach seems to make things a lot easier, I’ll try it out. Thanks for the input !