ah, im probably just supposed to call "zip" not zip-folder directly. From the https://github.com/komcrad/clj-file-zip#example

Zip a folder recursively:

(zip "/tmp/folder" "/tmp/folder.zip")

You're probably right. Another consequence of that entry-name parameter in zip-folder is that you can add files/dirs to the zip file under a path other than that of the input.

@U0DJ4T5U1 not a response to your question but related: you might also consider https://github.com/babashka/fs, it has some zip/unzip support and offers a nice general fs API.

An entry here is a single file within a zip containing 1+ files. This fn is kind of weird. It walks through a dir, writing files, but ignoring the directories themselves. So entry-name is only used written files, and those names are all getting read from the File objects anyway. You could eliminate the entry-name param by just reading name from the`File` at the beginning.

(if (.isDirectory folder)
  ...
  (do (zip-folder (first children) (str entry-name "/" (.getName (first children))) output)
      ... )
  ...)

;; changes to ---->

(let [entry-name (str entry-name "/" (.getName (first children)))]
  (if (.isDirectory folder)
    ...
    (do (zip-folder (first children) output)
        ...)
    ...))

Thanks @UE21H2HHD i think moving forward i'm going to use babshak anytime i need to do stuff that's "easy" for me from the command line like this.

and thanks @U90R0EPHA that explanation make sense.

flatten?

flatten should be https://stuartsierra.com/2019/09/25/sequences-in-flatland

E.g. flatten will remove all nesting. If you want a vector, combine it with vec:

(vec (flatten x))

(reduce into [] [["AA"] ["BB"]])

Yeah, or:

user=> (into [] (mapcat seq) [["A"] ["B"]])
["A" "B"]

(`reduce into` is a bit weird as into uses reduce internally, plus transients)

(mapv first <urvec>)

The point of "avoid flatten" is that if you find you need to use it, the problem is usually somewhere else, e.g. it's very likely that [["foo" "bar"]["baz"]] is the result of having used map earlier instead of mapcat. Or if it's external input, there is probably a schema, so you already know how to bring the data to a more flexible form, flatten can be too destructive. The takeaway isn't "never use flatten" but "think very hard about whether you really need it".

Yeah, sure. If you don't now about mapcat and end up with too much nesting you should probably not get into the habit of just calling flatten on the result. However, if you have nested data that you want to denest, well, use flatten? The same advice holds for all suggested alternatives by the way.

(into [] cat foo)

@UE1N3HAJH can you explain?

Sure, sorry. cat is a transducer which concatenates the contents of each input. That means it unpacks each inner vector and puts the contents of each into [] which is better than flatten because it only unpacks one level, so you could safely have collections rather than strings.

Agree that flatten should nearly always be avoided. It's a code smell imo

(into [] cat [["AA"]["BB"]["CC"]]) ;=> ["AA" "BB" "CC"]

thank you everyone 🙃

Flatten flattens a deeply nested structure. If you didn't expect that, flatten could introduce an accidental bug, if later you happen to nest more things that you didn't want to flatten. That's the reason people say to "avoid" flatten. But it's bad advice, the reality is, don't flatten more levels than you need unless that's what you want. So use flatten to flatten all levels. And when it comes to flattening deeply, the question becomes, what do you want to flatten? Like only vectors, or also seqs, maps, strings, arrays, etc. Or only some of those? So flatten will flatten all sequential?, and maybe that's not what you want. There's nothing wrong with flatten, other than, it might not do what you want even if it can fool you as if it does on trivial examples.

When it's more than one thing

Or when you want to use it as an argument to filter or comp

Thanks, @UK0810AQ2.

The filter/comp thing is because = returns true/false while a singleton set returns the value. For this reason, it’s also useful for some

Sorry I’m late. I haven’t looked here in a while 🙂

you can supply multiple collections to map https://clojuredocs.org/clojure.core/map

I.e. (map * a b c)

❯ clj
Clojure 1.10.3
user=> (map * [1 2] [1 2])
(1 4)
user=>

🥤

That is amazing

Thanks!