I think you want ns-resolve

I tried but my input is the ns that :refers and an unqualified symbol and ns-resolve was returning nil

oh, missed that bit

“symbol that is referred”

will try again though, maybe I am doing something odd, thanks!

uuuh, probably what you have, but that’s a super weird use case

so actually you are right

user> (ns orchard.test-ns (:require [orchard.test-macros :as test-macros :refer [my-add]]))
nil
orchard.test-ns> (in-ns 'user)
#namespace[user]
user> (ns-resolve 'orchard.test-ns 'my-add)
#'orchard.test-macros/my-add
user> (ns-resolve 'orchard.test-ns 'orchard.test-ns/my-add)
nil

the latter case is fully qualified and that is what's not working

(obviously)

ah, yeah, the former is how ns-resolve works–resolves a simple symbol in an ns

tnx for replying 😉

also ns-resolve is weird, and if you know the full ns you want something from already, you can use (resolve 'orchard.test-ns/my-add)

that is, ns-resolve asks for a symbol to be resolved as if you were in some other ns, and resolve is just "get me the binding of this symbol", which seems more direct to me

I think ztellman's virgil lib is made for this sort of thing https://github.com/ztellman/virgil

Thank you! But I was thinking more about runtime isolation, I will try https://github.com/RutledgePaulV/clj-embed o/ thanks

i always forget I made that. I should probably clean it up and make it work for git deps, etc

Great work, BTW @U5RCSJ6BB o/

(defn applesauce [s substitutions](->> (clojure.string/split s #" ") (replace substitutions) (clojure.string/join " ")))

It’s a bit limiting tho in that the substitutions have to happen on words

“concat” would not become “condog” in my example

isn’t that what raining -> snowing is doing?

clojure.string/escape is the closest function to what you are asking about that is built into Clojure.

> isn’t that what raining -> snowing is doing? yea sorry, I read the output too hastily. It actually returns "It is raining cats and dogs" which is incorrect.

For a general set of strings to be replaced, if they can overlap with each other in the input, one also would need to specify (or not care about) deciding what you want as output, e.g. if you ask to replace {"bare" "1", "aren't" "2"} , what should the output be for an input string of "baren't" ?

That question is not applicable for clojure.string/escape , because it only allows individual characters in the "to be replaced" set, not arbitrary strings.

That kind of restriction certainly eliminates most, if not all, cases that could otherwise be ambiguous. As long as the template separators do not occur in any other non-substitution places in the input string, of course.

I wouldn't be surprised if cl-format can do it, but haven't dug into all of its capabilities. reduce and clojure.string/replace should work probably-more-closely to what you want as long as the replacement strings also never contain the boundary characters < >

I believe that should be the case in this scenario

The main potential down side to combining reduce and replace is efficiency, if the number of strings to be replaced is large, since it will scan over the to-be-replaced string N times for N strings to be replaced. There are other solutions that guarantee passing over the to-be-replaced strings exactly once, of course.

Yea, in this scenario the perf cost might be prohibitive. Is there a name for the single pass algorithm?

Found this https://www.oreilly.com/library/view/python-cookbook/0596001673/ch03s15.html

With delimiters like < and > that are not used for any other purpose, it would be a simple kind of 'lexing' or parsing to find all of those in one pass, and for each one, look up the string in the map for its replacement.

At least the first solution there doesn't seem to mention what its behavior would be in the overlapping-to-be-replaced-strings case. It has some behavior in that case, of course -- I just do not know what it is off the top of my head.

Hm yea…does clojure have the regex.sub equivalent? That’s pretty cool how you can pass it a lambda in python.

user=>(clojure.string/replace "<foo> dog <bar>" #"<[^>]+>" {"<foo>" "cat" "<bar>" "bear"})
"cat dog bear"

this works because {} is a lambda in clojure, any other string->string function works there

the hard part was making the regex that only matched one <...> at a time :D

Wait…`replacement` can be a lambda??? 🤯

Try (doc clojure.string/replace) 🙂

it says so right in the doc string

user=> (clojure.string/replace "<foo> dog <bar>" #"<[^>]+>" clojure.string/reverse)
">oof< dog >rab<"

Oh my…I need to get my eyes checked

anyway, it's nice that there's such a direct answer to your question

This is great. Thank you @U051SS2EU 🙏

(defn equatable-any []
  (gen/such-that #(= % %) (gen/any)))

That looks like a good filter for most things you would want to generate via test.check

Right, I would rather require extra effort to the opposite than avoid that as the default

You can ask folks like Gary Fredericks in #test-check channel for back story if you want to dig further. I suspect backwards compatibility of the test.check library may play a role here.

It's both not wanting to change the meaning of things, but also there's a tension with PBT libraries and edge cases like this

On the one hand it's annoying to have to opt out of the edge cases you're confident you don't care about, but on the other hand a big reason to use a PBT library is to discover edge cases you weren't thinking about

So making them all opt-in can actually decrease the utility

Makes sense. Perhaps this is more of the genericness of the generators spec predicates like map? produce

I think you could make a good argument that map? shouldn't generate nans as keys in particular

Since you can't even look them up

But honestly the whole situation is terrible and there's no good answer and I think languages should never conflate floating point equality semantics with generic object equality

even java.util.IdentityHashMap, which is the only one I know of that uses identity instead of equality, still fails to match a nan key because it requires both identity and equality for some reason(???)

Regexes are a similar case

Yeah, I was shocked/annoyed the first time I discovered that regexes don't compare equal to themselves 🙂

But you can always pull the underlying string out of the regex and use that instead.

They do to themselves

Just not an identical regex

Ah, right. Yes, that was the issue I ran into.

user=> (= #"one" #"one")
false
user=> (= (.pattern #"one") (.pattern #"one"))
true