For example, when executing tests on some code related to the monkey-patch, I need to ensure that the related monkey patch is applied after loading the dep and before running the test. So I can stick the monkey-patch in the namespace that's being tested, but it seems like there should be a nicer way to declare that "I depend on this monkey patch" so that the loader will handle this for me?

What about this, this didn't work? https://clojuredocs.org/clojure.core/with-redefs

Ah I should clarify that I do have something working (doing in-ns and deffing it), but I'm looking to improve it 🙂 with-redefs is an option but I think I'd have to wrap it around my whole app and I'm not sure it solves the testing problem

Then make your own version of that library that exposes what you want...?

Also a possibility 🙂 Would be nice if it was possible to do without though, since it's a 3 line change...

Then you can copy the source code and do your change...

But that's not very upgradeable

Yeah and it's an internal function so I'd rather not copy a bunch of source code to get "deep enough" to where I can patch what I need

I needed something in golang for my master's. And there simply was no other way. I copied the sources and called it a day.

In clojure people may have small functions which would allow to hack and compose everything yourself. But in golang they have large blobs with lots of ifs. And if I understand you have the latter.

Also library authors in clojure sometimes make all internal variables private. Which blocks to do this monkey patching even if you want it.

Anyway. You could use reflection and code generation. But it's too sophisticated. You could look how PowerMock and Mockito work. And try something of that sort (heavy reflection).

Mockito can replace methods on a class. PowerMock can replace methods on a static final class (at least static for sure) and constructors, singletons.

> Also library authors in clojure sometimes make all internal variables private. Which blocks to do this monkey patching even if you want it. You should be able to reference the var directly even if it's private

Anyway, I guess my core issue is not how to do the monkey patching -- I have something that works. More how to ensure the monkey patch is applied consistently

https://github.com/powermock/powermock

You could run it in your main method. Who knows.

I think separate library is the most consistent and you will know that you do it every time.

Also you could have a build process that checks the library for you

So long as you require the namespace containing the var you want to patch before you patch it you can be sure your patch is applied after the initial load of the namespace. It doesn't guarantee that the library (or another library) doesn't monkey patch it's own var after that, but that would be pretty unusual.

When I monkey patch, this is how I do it:

(defmacro defpatch
 "An anaphoric macro for patching existing functions. Original function is bound to the symbol 'this'.Safe to execute multiple times, 'this' will always refer to the original implementation and never the previously patched implementation."
  [symbol bindings & body]
  `(let [var# (var ~symbol)]
     (alter-var-root var#
       (letfn [(define# [orig#]
                 (let [~'this orig#]
                   (with-meta (fn ~bindings ~@body)
                              (merge (meta orig#) {::original orig#}))))]
         (fn [original#] (define# (or (some-> original# meta ::original) original#)))))
     var#))

You already have set your constraint. You want it to be an integer. So probably it would be java.lang.Integer that you want. There is a function in Java's stdlib for that. But even then. This may have been clojurescript question. And there is no easy way to parse exactly integer without a floating point part.

Integer/parseInt or Long/parseLong , although IIRC parse-int is to be added in the latest and greatest version of Clojure?

https://clojure.atlassian.net/browse/CLJ-2451

@U46C250QM yes, but look at his title: "Author of Data-Oriented programming" This is not the guy who would ask this question to get the answer 😄

of course, but he asked a simple question with a simple answer 🙂 perhaps he intends to ask a different question

I didn't get the joke about the title of my book:hugging_face:

If you have that kind of a book then you can lookup the answer on your own. So probably the question was not what you were asking for.

In my book I deal with "principles" not with low-level implementation details:joy:

The answer @U46C250QM provided is exactly what I was looking for.

I would always prefer clojure.edn/read-string for any parsing purposes, but I guess it depends on the use case.

Sometimes you want to fail fast and with an exception. But edn reader would also be fine if you'd check that you get a number.

Reading will read the next token from a string, and is inherently a different semantic than parsing.

You mean because

(clojure.edn/read-string "123 4") => 123

yeah. (clojure.edn/read-string "1 fish 2 fish") ;; => 1

or even "1.234" returning a double when you want to parse a long. parsing has extra expectations - you want to parse the entire input and return a value of the expected type. In Clojure 1.11, we'll have parse-long, parse-double, parse-boolean, and parse-uuid added

reading is more about tokenization/lexing and reads the next valid token of any type

So for now, the way to go is Long/parseLong ?

yes, that would be my recommendation

You have a typo, missing the f in self. Is that in the source, too?

damn it!

yes, it seems in source as well

let me try

yes, stupid typo

thank you so much!

@UK0810AQ2 you are my saver!

Glad I could help While you're profiling, make sure you have profiling events enabled if on Linux and that you have debug symbols installed

thanks, but i am on macos same applies?

Partially, consult the docs, you still need debug symbols and a few flags for good results

roger! thanks!

To be on the same page - it's not syntax per se, it's just a keyword in Clojure. I'm just guessing here, but it looks like it's used to specify the type of the name parameter.

Is it using plumatic/schema?

is that for type coercion?

sure seems like it https://github.com/metosin/compojure-api/wiki/Coercion

Thanks @U02N27RK69K. Do you know if the empty string in this ex is supposed to be a default value?

[name :- String ""]

I'm guessing a default value, yes, but you should try it out and see

stick a nonsense word in there and perform a request against it

another data point here https://github.com/metosin/compojure-api/blob/master/examples/coercion/src/example/data_spec.clj#L12

https://github.com/metosin/compojure-api/blob/master/examples/coercion/src/example/spec.clj#L19

Wow this stuff is ancient.

I would reocmmend looking at reitit instead. It's the sucessor to compojure-sweet

Oh this is work, I don't get a choice. :^)

🙂

Check out https://github.com/nubank/matcher-combinators

I just use https://clojuredocs.org/clojure.data/diff and look for [nil? nil? dont-care] as passing

https://github.com/protojure/protoc-plugin/blob/1571e9951a00396f993ba47eccf11436b9203a2a/test/protojure/plugin/core_test.clj#L69

there are lots of options for examining nested data structures: • https://github.com/redplanetlabs/specter • https://github.com/noprompt/meander • see the Data Transformation section: https://www.clojure-toolbox.com/ • lots more, but those are the ones that I've found useful. for diffing, there's also multiple options. I've used https://github.com/lambdaisland/deep-diff2

lein-difftest, too, if you use lein

thank you all!