(:require [clojure.string :as ...])

what is a good name, as str is already a function

string

Lots of people use str as an alias for clojure.string, because str/lower-case doesn't cause any conflict with the clojure.core/str function.

@souenzzo You can use clojure.core/compare to get a result of -1, 0, or +1 when comparing two #inst's to each other.

what is the simplest string manip function which does camelCase to hypen-separated

ah, found this:

(defn kebab-case
  "Converts CamelCase / camelCase to kebab-case"
  [s]
  (str/join "-" (map str/lower-case (re-seq #"\w[a-z]+" s))))

@andy.fingerhut: I have n oidea why that works, but yes, it appears that namespace alias str does not collide with buildin function

aliases and vars live in different "namespaces"

@qqq When a textual identifier contains a "/" character, the thing before the "/" is tried to be resolved as either a full namespace, or as an alias of a namespace (I don't know off hand which order is checked for between those two). If there is no "/", no part of it is considered a namespace or alias, just a symbol on its own.

meh, can’t come to a solution 😩 I have a lazyseq (file-seq) which I have to iterate through while occasionally change a local data structure (fill and read a hash-table in this loop). Is loop/recur the right approach?

or reduce?

if you always move through the lazy-seq in order, reduce is simpler / more direct than loop

so it’s okay to work with only one hash-structure for both the “actual” work data and help data?

I’m not super experienced with functional programming yet…

using one reduce argument to hold both an accumulated result and ancillary data is common

technically it is possible, question is about whether it is a good way of implementation

alrighty, thanks! will try it out immediately

if you use transduce, you can even specify the function that gets the real result out of the accumulator

@noisesmith yeah, works as expected! didn’t try transduce yet, though

transduce is mainly useful if you are doing some transform on each item as it comes in

eg. replacing (reduce f init (map g coll)) with (transduce (map g) f init coll)

I’m iterating through a list of files keeping some information to exclude duplicates from being inserted into a DB… (file-hash, last-modified, path)

reduce might be enough for now, I think

sounds about right - the note about transduce was because including that feature indicates that it’s idiomatic to transform the accumulator to get your value out at the end

one advantage of loop/recur might be, that one can continue the loop from an arbitrary position, whereas with reduce, your nested if-clauses have always to return something…

just a guess

I should refactor a bit first

not arbitrary, it has to be from the "tail" position, so to speak

maybe it’s not that bad

oh I thought calling “recur” is similar to “continue” in other langs

nope

plus new bindings of course…

hm

you do always have to "return something"

it seems I didn’t understand loop-recur 😅

whether you're using loop/recur, or reduce, or anything else in clojure

does it mean if I have a nested structure, that i can’t call “recur” from the most inner level to jump straight into the next iteration?

you can, as long as that recur is still in the tail position

meaning, it needs to be the last thing that could get called

I should stop talking and try it out myself - I’m concerned that I start explaining my misunderstandings and embarrass myself 😄

(loop []
  (if blah-blah
    (if something-else
      (recur)
      (other-stuff))
    (foo))

in that example, recur is in the tail position

but your example would look almost exactly the same with reduce, wouldn’t it?

coincidentally, other-stuff and foo are also in tail positions

just that the else-branches would return the untouched collection

hm

well, it's a fairly contrived example, the else branches here are breaking out of the loop

ah, of course!

on can’t “break out” of reduce. one has basically to walk though the entire collection…

well, it's actually possible to break out of a reduce

because clojure provides a special way to signal that you want to break out early

but I'd avoid that until you're more comfortable with reduce and FP in general

reduced?

yep

loop/recur's name is a bit unlucky, since newcomers often think it's similar to an imperative loop

it’s an end-tailed recursion, right?

yeah

you can recur without loop, too

in which case it'll just recurse from the beginning of the function

*tail recursion

oh what

but without the tail optimization, correct? stack or heap would fill up

*with the optimization, you mean?

oh, I see

recur tells clojure to use tail optimization

just calling recur would omit optimizations

ah

what does loop do then?

if you just called the function itself you'd fill up the stack

loop just localizes it

ah loop is just the jump-point for recur?

yep

for when you don't want to go all the way back to the beginning of a function