Ι think most people have moved on to clojure.spec.alpha and malli, so you might get better answers at #C1923ED97. And it's better to just ask the questions, don't ask if you can ask them!

Feels like I just got transported to IRC. Are you a bot, @UEQPKG7HQ? 😁

I used it for many years and still honestly prefer it. what's your question?

Thanks for response @U03TPPC0R0T I posted question here https://clojurians.slack.com/archives/C1923ED97/p1666262764849469

Data in Clojure is immutable, so concat returns a new list -- it doesn't modify an existing one.

You're already using loop in average -- you'll want a loop in -main that accumulates the times. You'll want to turn the input from a string into a number, as well. parse-long if you're on Clojure 1.11. You don't need the iterator stuff: you can use first/`rest` in the loop and (seq l) to check for empty list of times.

Hope that helps point you in the right direction?

i think average is typically implemented using reduce https://clojuredocs.org/clojure.core/reduce i haven't read user input using the command line, but i remember that JDK has some scan API that makes that easy https://www.programiz.com/java-programming/scanner

you may benefit from reading through the collections API examples on clojure docs, also there are a lot of clojure books that should help starting off. you are writing clojure as if it's java, and clojure does things a bit differently from java, which are a little challenging to explain in a context like a slack Q/A

https://www.youtube.com/watch?v=P76Vbsk_3J0 this may help as well

Thank you pppaul and seancorfield! I don't have time to really look into these at the moment, but I appreciate the help! I'll definitely look at these when I get a minute

Also, it is considered poor form to use def as you've done so in line 14

You can use a let binding there instead

this isn't really oop, just imperative code

map-indexed gets you a sequence and its indices, so you can map over both with a single function, but it sounds like you want map-indexed + reduce here

you don't actually need the index at all

all you need is the previous value which the accumulator argument to reduce gives you

but there is also a built in function that basically will does this all for you, you can find it using (apropos 'reduc) in the repl

looping with a counter is fine too

(let [l [3 5 3 2 1 2]]
  (reduce #(conj %1 (-> %1 last (or 0) (+ %2))) [] l))

the sort of defining difference between imperative code and functional isn't so much the shape of it, different control structures or whatever, but the use of immutable values

Ah I see. Thats extremely helpfull. Thank you all 🙂

so you can write a loop that iterates over a counter, but you also need to keep the state of the new structure you are building up (because you aren't mutating an existing array), and possible a sort of cache of the running total

is that an imperative factorial I see there?

oh no, that'd be the products

(reductions + [3 5 3 2 1 2]) (i'm providing this solution for the sake of completion but as a beginner the reflex should be trying to solve it with reduce or loop/recur)