Can redefine a def, like I can a defn function with with-redefs?

I'm trying to write a test but I need to mock out a value

@caleb.macdonaldblack yep! https://clojuredocs.org/clojure.core/with-redefs#example-542692d6c026201cdc3270c1

@trailcapital Oh. I must have had a different error somewhere else when I tried that the first time. Thanks 🙂

I didn't see the example though. I just assumed it only worked with functions

Just bear in mind that some uses of def'd values are "compiled in" and won't be seen if you try to redef them...

user=> (def foo 42)
#'user/foo
user=> (def bar foo)
#'user/bar
user=> (defn quux [x] (+ bar x))
#'user/quux
user=> (quux 0)
42
user=> (with-redefs [foo 13] (quux 0))
42
user=> (with-redefs [bar 13] (quux 0))
13

bar is compiled to refer to the value that foo has at the time -- so redefining foo has no affect on bar's value

Ah yeah I'm aware of that one. Had some issues in the past working with pedestal around that. I was reevaluating functions in the repl that were referenced in interceptors defined with def and trying to figure out why it wouldn't work.

I was surprised to see that vectors don't implement ISeq. (seq? [:a :b]) is false. Can anyone shed some light for me?

https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/ISeq.java -- vectors don't support those operations, they need to be coerced to seqs

seqs are logical lists

seq is the operation that yields the seq view of a collection (which often is not itself a logical list)

things that can be seq-ed are seqable?

@seancorfield I looked at that briefly but I think i got tunnel vision on determining what can have first called on it and figured seq? fit that bill and vectors satisfied that. But I forgot about next and more

thanks @alexmiller. My gut still tells me that vectors are certainly logical lists. (I don't mean this argumentatively, i mean i'm trying to fix my thinking/reasoning)

But i'm reading the http://clojure.org stuff again trying to internalize this so I develop that intuition. But it sounds like seqable? would guarantee that first will succeed

and thanks both of you for answers so late 🙂

vectors can provide a logical list view (an implementation of the seq interface)

but they do not directly implement the seq interface

seqable? guarantees that first will succeed after you call seq on it

(seq [:a :b]) -> (:a :b) and (seq? (seq [:a :b])) will be true (he says, without trying it in a REPL!)

you will note that first does the seq call for you

user=> (doc first)
-------------------------
clojure.core/first
([coll])
  Returns the first item in the collection. Calls seq on its
    argument. If coll is nil, returns nil.

calls seq on its argument

well that makes it dead simple doesn't it 🙂 Thanks again

most of the seq-oriented functions do this

Note also

user=> (seq? #{:a :b})
false
user=> (seq? {:a 1 :b 2})
false

But both are seqable? and when you call seq on them, you get things that are seq? (`ISeq`)

yeah i was looking at seq? first. I think since lots of things call seq for me transparently i don't often have to worry about seq/seqable and that's why when it matters i a little mushy

but of course, the doc strings

Does there exist a macro like if-let or when-let that works with destructured bindings?

I suppose I could roll my own but it doesn't seem to make sense for (if-let [[x y z] val]) to always evaluate to the true branch no matter what the val is

both of those can use destructuring

if you want something other than what they do, then you would need to roll your own

if-let / when-let will respect depend on whether val is logically true or not

user=> (if-let [[a b c] nil] "t" "f")
"f"
user=> (if-let [[a b c] [1 2 3]] "t" "f")
"t"

aha, that makes a lot more sense now

somehow I always thought of it in terms of the truthiness of the left side of the bindings

it's really x in (if-let [[a b c :as x] val] ...)

(defmacro if-let*
  "Like `clojure.core/if-let`, but only evaluates to `then` if all bound vars
  are truthy, including destructured ones"
  ([bindings then]
   `(if-let* ~bindings ~then nil))
  ([bindings then else]
   (let [bindings* (destructure bindings)]
     `(let* ~bindings*
        (if (and ~@(->> bindings* (partition 2) (map first) (distinct)))
          ~then ~else)))))

(if-let* [{:keys [a b]} {:a 10}]
  (+ a b) :error)
;; => :error

I'm amazed all the time how easily Clojure lets you invent your own syntax 🙂

is stm commonly used, or it’s just an overkill?

when compared to atom.

I think it is used fairly seldom.

You might use it more often in a desktop application or database or something like that. But a lot of modern applications can be written without state.

is this thing up to date: https://clojure.github.io/tools.emitter.jvm/ ? is there some other built-in way to grab compiled bytecode?

what do you want to do with compiled bytecode? Disassemble it and print out the disassembly listing, or decompile it back to approximately equivalent Java source code? clj-java-decompiler can do either of those things: https://github.com/clojure-goes-fast/clj-java-decompiler

whats the easiest way to get expensive map-operations (that rely on external stuff like web-requests) to execute in paralell?

little p before map

aka pmap

@andy.fingerhut i want to ship it over the network into different vm runtime as part of deployment process

I'm trying to use sorted-set-by to represent a priority queue, but ran into the case where trying to conj an element with the same "priority" results in a no-op:

(let [cmp (fn [x y] (compare (:cost x) (:cost y)))
      s   (sorted-set-by cmp {:cost 0 :color "red"})]
  (conj s {:cost 0 :color "green"}))
;; => #{{:cost 0, :color "red"}}

is this the wrong data structure to be using? I thought of some workarounds like checking for 0 in the comparator and returning 1 instead, but that feels quite hacky

@qythium probably you're getting hit by this - https://clojuredocs.org/clojure.core/sorted-set-by#example-542692d5c026201cdc327096

hmm, hash-maps don't implement IComparable though, is it a good idea to compare their hashes as a fallback?

@qythium there is https://github.com/greglook/clj-arrangement if you want

do protocol and multimethod bring too much complication because to understand what to call, the user have to grok over all the codebase.

this is because the definition of protocol and (multi)methods can be dynamically added.

instead of appearing solely in the class definition.

The a la carte nature is what makes them simple. It does make searching for them harder though.

why do you have to search at all?

as a consumer, you just subscribe to the abstraction

My experience is that often in codebases, the abstraction is poorly documented so the implementations are the documentation. There's also the cases where you make a breaking change to the protocol, because it's internal, and then you need to search for them then too.

these seem like problems of your own making :)

in general, we have found that it is best to never have someone call directly into your protocol as an API, but to instead front it with a method that gives you a point of modification on top

so like in spec, there is a Spec protocol with methods like conform*, but users don't call that, they call conform function, which calls conform* on your behalf (and has its own custom logic to deal with stuff, like resolving spec name to spec object)

in practice, we've found this greatly improves your ability to create good abstractions that survive over time

More specifically, they are problems someone else creates for me to clean up / live with!

well, I mean "you" in the general sense (could also be "you" of 6 months ago :)

I've seen you mention this before, and beyond having additional logic in the fronting function (only call the underlying protocol on Tuesdays, or reverse the arguments) I wasn't sure of what the general case was there. The fronting function wouldn't help with understanding the abstraction though would it? What sort of things do you find it useful to do in that fronting function?

add a docstring 😄

you can spec the fronting fn for one 🙂

all of the above and often you'll find there is some special case or transformation that applies to all cases

anyone seen this behaviour where (seq (.getURLs (.getContextClassLoader (Thread/currentThread)))) is empty? this is when eval'ing inside nrepl/cider on a new clojure-cli based project

it's pretty annoying because it means io/resource sees an empty classpath and so won't find any resources

i did it in our work project nrepl/cider based project and also in just clj and both came up nil

also in core.match with clj and also responds with nil

io/resource works in clojure with cider nrepl generally. io/resource doesn't loop over each url. Is (io/resource "clojure/core.clj") returning nil for you?

no, you're right, it does find "clojure/core.clj"

I have :paths ["src" "test" "resources"] in deps.edn, and a file resources/activities/system.edn, but (io/resource "activities/system.edn") returns nil...

Did the folder exist when the jvm started?

good question... let me restart

(I spent hours on that once, now it's my first question)

and that fixed it. Thanks @dominicm!

Is there any way to add add "middleware" to clojure.tools.logging to change the format of what is logged when calling info, warn, debug, etc?

would wrapping it in another function be enough?

When using Transit ( https://github.com/cognitect/transit-format ), how closely does the version number need to match? I am communicating between the -clj and -cljs implementations, and the highest common release version between them is 0.8.247

But I am getting a difference in the data after translation when using both of them on that version number

Namely, keyword values of a nested map are turning into strings when sent from clojure -> clojurescript

> Watch out, logging is macro based, so you should wrap it with macros too -- @dominicm @ https://clojurians.slack.com/archives/C03S1KBA2/p1567093683142300?thread_ts=1567093003.139200&cid=C03S1KBA2 Why should one wrap macro usage (only?) in another macro? (I didn't want to hijack that thread with my n00b question.)

there is a function for (my-fn [1 2 3 4]) ;;=> {1 2, 2 3, 3 4} ?

oh, I misread

no built in, this is likely the most natural way to do it

user=> (apply hash-map (apply concat (partition 2 1 [1 2 3 4])))
{1 2, 3 4, 2 3}

user=> ((fn [xs] (zipmap xs (map inc (butlast xs)))) [1 2 3 4])
{1 2 2 3 3 4}

java-time related question: how do I truncate a java-time value, if I want to truncate it by any arbitrary unit?! java-time/truncate only accepts predetermined units such as 1 second, 1 nanosecond, ...

Do I have to turn the timestamp into a numerical value (unix time), do computation there and return it? or is there a simpler native way?

(my-truncate timestamp (java-time/minutes 39))

@veix.q5 you might want to look at clj-time to see if there’s anything in there that will do this for you

I don’t know off the top of my head. I do know that it has a lot of useful functions.

can you explain what you mean by truncate? Truncate only takes a unit as you truncate to that unit. It truncate to the month would be 2019-08, truncate to the year would be 2019. What does it mean to truncate 39 minutes?

@dpsutton well my understanding is that time itself is a sequence of delta-ts (iterate (partial + delta-t) origin) , 2019-08 is basically an imaginary representation.

i guess. but widely agreed on

when's the last 39 minute duration depends on when we all started counting 39 minute blocks of time

I didn't catch your last sentence

if you want to truncate to the day or month, we all agree on those and can easily do so. If you want to truncate to an arbitrary last duration, it depends on when the durations began.

but maybe i'm misunderstanding you as i still don't know what you would expect to result from truncating the current time by 39 minutes

day or month units and the overall human representation of time (the way they split seasons and rotations of the sun) are built into a whole, which is good for our monkey experience. what I'm saying is that with a representation that is more fine-grained, I could have both the monkey time AND the simple time.

can you tell me what you expect from truncating the current time by/to 39 minutes?

trivially speaking, you can just round an ms ts to the nearest (* 1000 60 60 39), but based on what starting point?

we don't and won't have a data type that is rounded to 39 minutes

I have a timeseries that is supposed to be divided into time windows. the size of the windows is algorithmically discovered through finding an optimum solution to a model.

the starting point never matters. what matters is the delta-ts.

then you don't want a time type, you want an interval type

this might help https://docs.oracle.com/javase/tutorial/datetime/iso/period.html

or you can just use eg. MS and then do the standard rounding / quotient / truncation etc. math

by the way, I guess the starting point matters when consensus is needed.

I could imagine a representation based on a starting / synchronization point and a period, but I know of no standard data type that works that way

we use data types like this in audio synthesis but typically it's simplified by a procedural representation where time is nearly always processed incrementally in order when these artificial periods come into play