Probably best not to cross-post Qs between channels. You got an answer in #test-check, you just needed to be a bit more patient than eight minutes!

Can that string be inside an attribute map?

Have you tried a version with reduce and reduced? https://clojuredocs.org/clojure.core/reduced

I can't imagine how that would be simpler than the above. I'd use flatten here with a filter on top if maps shouldn't be checked for strings. And tree-seq if they should be.

@U2FRKM4TW No it's not in an attribute map so I don't want to recurse into them. It's a direct child of a hiccup vector. And I'm assuming there's only one match in the whole tree. I just realized I could make a couple small optimizations to what I have and I edited the function.

Yeah, just make your own version of find-first in a sequence, and then flatten + filter for strings + find-first.

@U2FRKM4TW Oh wow I didn't realize I could use flatten 🤯

My two cents… Reduce avoids lazy sequences and can terminate early. You might find it performs better in terms of both space and time. By avoiding stateful constructs like atoms the solution is simpler. It might not be easier to code but that gets us into simple vs. easy. A little imagination goes a long way. Jumping into a hammock and thinking a little more can yield better results. Without all the information it's hard to say but having people willing to help is awesome. It's always exciting finding out something new about Clojure’s core functions. There's lots of good stuff ready to go, which makes me happy. I'm glad you found out about this awesome feature, @U019RSW97UZ. 💪

@U06FTAZV3 Oh dang I didn't realize we had a function like reduced, that's seriously cool. Double mind blown 🤯😄

A little update, I got a reduce/`reduced` version working and wow it's clean af. Thanks @U06FTAZV3!

(def some-hiccup
  [:div
   {:id "baz"}
   [:p "foobar"]
   [:section]
   [:section {:class "test"} "foo"]
   [:section [:p "foobar"]]
   "bar"])

(defn search-for-str [hiccup]
  (reduce
   (fn [_ item]
     (let [desc-result (and (vector? item) (search-for-str item))]
       (or (and (string? item) (re-find #"foobar" item) (reduced item))
           (and desc-result (reduced desc-result)))))
   hiccup))

(comment (search-for-str some-hiccup))

Maybe this?

(let [locked? (atom nil)]
  (defn func []
    (when-not @locked?
      (reset! locked true)
      (some-once-code))
    (normal-code)))

delay?

delay might do it as every time a new delay obj is created.

might not do.

core/exists? tests if a name exists, can I create a name under an ns without using def , clj-kondo by default warns on inline-def.

You can put the delay outside, e.g.

(defonce foo (delay (once...)))
(defn func [] @foo (normal code))

I am curious as to why it's desirable to contain the "some-once-code" within another function Otherwise defonce by itself seems acceptable

(defonce static-value (some-once-code)
(defn func []
  (normal-code))

> unless the developer expressly evaluates the def expression Or unless the namespace is reloaded.

> I am curious as to why it’s desirable to contain the “some-once-code” within another function Because the logic belongs within the enclosing function, so I want to make it more self-contained. And it also depends on the enclosing functions input parameters, so in that case, put inside the enclosing function is a must. It’s like the static declarator in c++.

There's also memoize. You can come up with a bunch of ways of how to use some of all those things together to achieve what you need.

@U2FRKM4TW Neither satisfy the initial requirement. The closest is what magnars posted.

If you decide to go with that, don't use deref+reset. Instead, use a single swap.

compare-and-set! might be more direct.

(let [init (delay (println "once"))]
  (defn thing []
    (deref init)
    (other-code)))

or @init

> it also depends on the enclosing functions input parameters

oh missed that

Its pretty weird to want to do that, sounds like you're implementing a poor's man object oriented system?

If you want a scoundrels object oriented system, boy do I have a 2 year old gist oozing at the seams

Anyways, I would use a promise personally:

(let [p (promise)]
  (defn foo
    [a b]
    (deliver p <code-to-only-run-once>)
    (do-thing-with @p)))

(let [v (volatile! nil)]
  (defn foo
    [a b]
    (when (nil? @v) (vreset! v <code-to-only-run-once>))
    (do-thing-with @v)))

(let [ran (volatile! false)]
  (defn foo
    [a b]
    (when-not @ran
      <code-to-only-run-once>
      (vreset! ran true))
    (do-other-things)))

(defn make-some-fn
  [a b]
  <code-to-run-first-time>
  (fn [a b]
    <function to run thereafter>))

(defprotocol PFoo (do-somthin [a b]))
(defrecord Foo [some state]
  PFoo
  (do-somethin [a b] <wtv-you-want>))
(defn make-foo [a b]
  <do-something-once-at-construction-with-a-b>  
  (->Foo a b) ;; assuming a b is state you need afterwards
)

(ns Foo)
(defprotocol PFoo (do-somthin [a b]))
(defrecord Foo [some state]
  PFoo
  (do-somethin [a b] <wtv-you-want>))
(defn make-foo [a b]
  <do-something-once-at-construction-with-a-b>  
  (->Foo a b) ;; assuming a b is state you need afterwards
)

(do
  (defprotocol PFoo (do-somthin [a b]))
  (defrecord Foo [some state]
    PFoo
    (do-somethin [a b] <wtv-you-want>))
  (defn make-foo [a b]
    <do-something-once-at-construction-with-a-b>  
    (->Foo a b) ;; assuming a b is state you need afterwards
  )
)

Oups, actually nevermind, you do need to deal with concurrent calls to the function, and the variable is actually shared between calls, so promise would work, or like you said, compare-and-set! with an atom. Hum... actually compare and set might not be thread safe here either, since it's not blocking. Like it wouldn't re-run the code, but if another function is running shouldn't it wait for that code to have ran? If so, promise really seem the right way to go.

it does work. maybe you expect different result?

I’d expect it to be {:a [{:x [6]}]}

update-in does not assume that integer in path means vector. It will always create a hash map if not present in m

You can find this in the docstring

code that updates is usually distinct from code that initializes

Yes. I am aware of that. I just don’t know how to achieve the desired result.

I am fine with specter or other tool (if applicable).

if-else-ing on the data structure to check if it already contains a vector is, , might be little error prone and verbose.

You can write your own version of update-in

Think this would do it:

(defn update-inv
  [m ks f & args]
  (if-let [k (first ks)]
    (if (next ks)
      (update m k (fn [old] (if (or (nil? old) (empty? old))
                              (if (number? k)
                                (apply update-inv (into [] (repeat k (f nil))) (next ks) f args)
                                (apply update-inv {} (next ks) f args))
                              (apply update-inv old (next ks) f args))))
      (if (or (nil? m) (empty? m))
        (if (number? k)
          (apply update (into [] (repeat k (f nil))) k f args)
          (apply update {} k f args))
        (apply update m k f args)))
    m))

Haha. Using my clojure power to understand it.