Like what?

ns-unmap

I am usually really lazy and just comment out the body of the test and leave the deftest in place so it redefs as an empty test

I just found

(remove-ns (ns-name *ns*))

It seems to do the job 🙂

That will clean the whole namespace. Fine if that works for you, but (ns-unmap *ns* 'foo-test) is more direct to your issue.

Alright!

i think the best place to ask this is on http://ask.clojure.org . It will get the attention it needs there

thanks, asked https://ask.clojure.org/index.php/12390/provide-slf4j-2-0-factory-for-tools-logging

JUL is both (1) an interface that receives messages to log, and (2) the custodian and writer of a file. Let's stipulate that JUL does a lousy job in both its roles. But the proliferation of slightly-improved loggers AND 99,999 slightly-lossy adapters every-which-way among them and JUL suggests that application integrators forgo nearly all the improvements to the (1) interface, and the net improvements of alternative loggers are in the disposal of messages to a file or whatever.

@U0HG4EHMH This is my poor english, but it is not clear for me you are saying + or - for using JUL 🙂 > Let’s stipulate that JUL does a lousy job in both its roles. Can you extend? I don’t write to file, but to STDOUT in cloud world.

But if you mean JUL is like a base version for logging and frameworks are extended logging with ready to go solutions, then sure it is true.

At the same time I have feeling (like with all frameworks) if you want to do something custom, then framework start to be frustrating experience and better do it with JUL.

and so far I didn’t find anything in JUL what I need and can’t do. Maybe even faster, than reading framework log documentation heh

this is a consequence of the new trailing map support

so, not a bug, new intended behavior

😞

at least I suspect that's the case, this is kind of a weird combination of things?

> this is kind of a weird combination of things? I'm not sure what you mean by that. It seems like the semantics of destructuring are now different for lists/lazy-seqs than for vectors. Heretofore I've been treating all sequential types the same when it comes to destructuring, but apparently I can't do that anymore.

that associative destructuring of a sequential thing does anything outside the case of & args is not anything that has ever been documented. what do you expect it to even mean to do associative destructuring on a sequential collection of one element?

in 1.10 previous, that had no meaning. in 1.11, a lone element in this case is treated as a map on which to destructure

it having this effect only on a seq? is a result of the expectation here being that it's used for & args (which are always a seq)

> what do you expect it to even mean to do associative destructuring on a sequential collection of one element? My only expectation was that associative destructuring on lists/vectors/lazy-seqs would all work the same.

associative destructuring on lists/vectors/lazy-seqs is not defined

> associative destructuring on lists/vectors/lazy-seqs is not defined I don't think this is true anymore. I think associative destructuring on lazy seqs has now been defined.

no, it's still undefined

if you're doing a thing that's undefined, you don't get to have expectations :)

what's defined for sequential collections is sequential destructuring, and nothing has changed there

A colleague brought up this issue at work a couple of days ago, and I’ve bumped into it myself multiple times. I think the main problem is that the new behavior is particularly confusing when you’re refactoring a function that used to accept one map into one that accepts a seq of maps. It’s easy to remain under the illusion that everything works fine, even though it doesn’t. For example:

(defn make-move
  [{:keys [name move]}]
  (printf "%s uses %s!\n" name move))

(def pikachu {:name "Pikachu" :type :electric :move "Thunder Shock"})

(make-move pikachu) ;; Pikachu uses Thunder Shock!

;; Then, you realize make-move must accept a seq of Pokémon instead of just
;; one, but forget to update the function.
;;
;; You make a callsite that gives make-move a lazy seq:
(make-move (map #(select-keys % [:name :move]) [pikachu])) ;; Pikachu uses Thunder Shock!

(make-move [pikachu]) ;; null uses null!

(make-move (map #(select-keys % [:name :move]) [pikachu]))
;; Execution error (IllegalArgumentException) at user/make-move (REPL:1).
;; No value supplied for key: {:name "Pikachu", :move "Thunder Shock"}

(def charmander {:name "Charmander" :type :fire :move "Ember"})

(make-move (map #(select-keys % [:name :move]) [pikachu charmander]))
;; null uses null!

(The silly map ... select-keys thing is just meant to illustrate how a callsite might end up passing a lazy seq to the function.)

The difference between lazy and non-lazy seqs is also unfortunate, because when you start debugging the function at the REPL, the first thing you’re going to try might be something like (make-move [pikachu]), and then you’re doubly confused about the different end result.

it's not lazy vs non-lazy, it's seq? vs not seq?

Ah, indeed. 👍

(str '(defn foo [s] (println "Foo" s))) is basically (str (eval '(defn foo [s] (println "Foo" s))))

and that is why it removes the quote

Hmmm, I actually need this in ClojureScript, where I don't have eval...

then don't quote things

It's not as if I can choose...

' is short hand for (quote ...)

the data you are reading contains the quote, so that is what you get when you read it

(quote ...) is just a two element seq, where the first element is the symbol quote

I know. It's not me quoting things. I'm reading a file where some items are quoted and need a string representation that will print exactly as it ”looks” in the file.

Maybe this can't be done with ClojureScript?

Thanks, @U0NCTKEV8! 🙏 For now I'll update the README of the project and inform that quoted code is not supported. 😃

@U0ETXRFEW no need for eval, can also use second:

(->> "'(defn foo [s]\n (println \"Foo\" s))"
       read-string ; => '(defn foo [s] (println "Foo" s))
       (clojure.walk/postwalk #(cond-> % (and (seq? %) (= 'quote (first %))) second)))
  ;; => (defn foo [s] (println "Foo" s))

Wonderful, @U5H74UNSF! 🙏 ❤️ It works!

Of course I have a second requirement that the single-quote should be kept in the resulting string. After some trial 'n horror I think I nailed that too:

(defn- single-quote-second
  [x]
  (if (symbol? (second x))
    (symbol (str \' (second x)))
    (str \' (second x))))

The horror part of this last exercise was that I first tried with an anonymous function, but that yields totally different results! I get the compiled JavaScript code instead...

Of course now you have the opposite problem, don't you? If I am following correctly, a literal (quote ...) will also be turned into ' now. And what about ` ?

Would it be too much overhead to check the original string for what type of quote was used?

Maybe a custom reader that builds that in?

You are right, of course, @U90R0EPHA. Now I have the reverse problem. ...

I'm doing something similar to what pprint does.