yeah that is wrong. chatgpt isnt guaranteed to be correct 😛

Wow, OK, I just wanted to have someone who knows more than me confirm. Thank you...

there's only so much that can be fact checked, take things it says with a grain of salt, not as absolute source of truth 😄

I got this from chatgpt ‘(defn find-first-greater-than-5 [vector] (first (filter #(> % 5) vector)))’

@U2T2ZEVPC, would that be the best way of doing it?

I mean is the ChatGPT recommendation the best?

Interesting.. still not so good

How would you do it?

Sorry, That was correct. I wrote down >5 😅

(some #(when (> % 5) %) [1 2 3 4 5 6 7 8 9 10]) should be better i think

stops at the first match, unlike filter

That is interesting ...

Would have never though of using these 2 functions.

Does it matter much performance wise if I use filter or the some solution? Because filter returns a lazy sequence?

also filter + first will realise the first 32 elements

And if you want to not create an unnecessary seq just to drop it after the first call, some is better. I’d use filter if I’m using the seq in other places too, not just for the first call.

And looking at the source for some and filter, some is more more succinct...

filter & first might be technically less efficient but some & when is far less intuitive and this is #beginners. In other words, filter & first is a perfectly fine answer to this question (I'd only maybe suggest some & when if this question popped up in #clojure)

Not in Clojure core but I use medley.core/find-first

assuming cljs-ajax, handler just gets the response, and the fn's arglist is destructuring, so in the case when a response is sequential (e.g. a vector of maps), ok will be bound to first item and response will be bound to the second. In the case where response is a map, the destructuring fails because maps aren't sequential (which is why nth isn't supported on them, and nth is used to destructure)

...so you could destructure using map destructuring, or not destructure at all and do whatever you need to do with the response, maybe checking whether it's a list or a map if your call might result in either

@UPBB20W20 It is not clear from your example code what is not working. Like, what is "it" in "it works" and "it doesn't work"? That said, I will hazard a guess based on the question: We do have to adjust our response parsing to whatever the source cares to send along. So (still guessing), where you have (first response), try (first (:data response)) -- to handle this source. Hth!

thank you guys that was silly mistake :/ I'm still confused with handler function. Like passing 'atom app-state' to handler function. (defonce app-state (atom {:tags [] :music-videos []})) (get-tag-list app-state) (defn get-tag-list [app-state] (ajax/GET "" {:handler #(swap! app-state assoc :tags (:data %)) :response-format :json :keywords? true})) In PHP I would just return data from 'get-tag-list' a then save it somewhere. In my next step I need to make a <ul> <li> list from result of this api call. Do I have to create another atom and pass it to :handler? Can I just make a html list right away?

The package info has a pretty good overview, https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/time/package-summary.html

It looks like you want LocalDate, https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/time/LocalDate.html#ofInstant(java.time.Instant,java.time.ZoneId)

The java.time is pretty functional on its own. I've never really felt the need to wrap it (not that thers's anything wrong with wrapping).

see I thought so but

(time/local-date (time/instant (.lastModified (first reports))))

Execution error (ExceptionInfo) at java-time.defconversion/call-conversion (defconversion.clj:69). Could not convert [#inst "2023-02-17T17:32:33.509000000-00:00"] to class java.time.LocalDate!

If you look at the second link, converting from an instant to a localdate requires a ZoneId

getting closer

(let [reports (file-seq (io/as-file path-to-reports))]
   (.ofInstant (time/instant (.lastModified (first reports))) "CST"))

you probably want (java.time.ZoneId/systemDefault)

(java.time.LocalDate/ofInstant
 (java.time.Instant/now)
 (java.time.ZoneId/systemDefault))

ofInstant is a static method of LocalDate

(let [reports (file-seq (io/as-file path-to-reports))
        zone-id (java.time.ZoneId/systemDefault)]
   (.ofInstant (time/instant (.lastModified (first reports))) zone-id))

No matching method ofInstant found taking 1 args for class java.time.Instant 

which would make me think my parentheses are wrong but I really don’t think they are hmmmm

oh, now I see

kind of

I don’t think I understand how to static method

it’s not time/LocalDate/ofInstant

no worries, java interop can be a bit tricky at first

it's java.time.LocalDate/ofInstant or LocalDate/ofInstant if you've imported LocalDate

so this

(java.time.LocalDate/ofInstant (time/instant (.lastModified (first reports))) zone-id)

when you say “imported”

you mean something different than require

yes, there's an optional :import allowed in your ns statement

I was expecting to be able to replace java.time with the time alias in my require

(ns my.ns
  (:require ...)
  (:import java.time.LocalDate))

so do I have this right: I was trying to use functions defined in the namespace java.time. But to use the static method of the java.time.LocalDate class (class?), it must be imported

(or fully qualified I spose)

at any rate, that’s my problem solved, thanks so much

One more bit of java interop confusion: This function is fine

(defn creation-date [report]
  (LocalDate/ofInstant (time/instant (.lastModified report)) (ZoneId/systemDefault)))

(defn creation-date [report]
  (-> report .lastModified time/instant #(LocalDate/ofInstant % (ZoneId/systemDefault))))

I bet it’s because -> is a macro

but that’s where my guess stops

I think the # is unnecessary

ah ha, that’s it — I forgot that what’s being passed will be the first argument

not that the threading version is that much more readable, but I was wondering if it was interop

generally, anonymous functions inside of threading macros usually don't do what you want

> (read-string "#()")
(fn* [] ())

> (clojure.walk/macroexpand-all '(-> foo #()))
(fn* foo [] ())