you can also use this, it's quite nice https://github.com/babashka/fs

and then you can just call path with multiple arguments https://github.com/babashka/fs/blob/master/src/babashka/fs.cljc#L43

it's a single file, too, which is nice

( some-dir inner-dir file-name) also works

(i totally didn’t see that you found this on your own, whoops 😛 )

Was going to link https://clojureverse.org/t/how-to-join-file-paths/814/6

I have a bunch of not too wild types that try to mimic clj data structures to some extent here if you want to skim a list of potential interfaces or protocols https://github.com/sicmutils/sicmutils/search?q=deftype&type=

I’ll check that out!

oh this is awesome

was originally a Christophe Grand hack, but you can find a variety of variants of it around with embellishments

the one in Clojure Applied includes the Java methods and their mappings to Clojure fns. I would share it but copyright etc

I need to read that book one day! 🙂

But I should finish the above diagram, filling in the missing pieces, etc. Despite its shortcomings, I still find it useful

you should never need eval really, its a dangerous operation (may allow remote users to run arbitrary code if not used with a lot of care).

I've doing Clojure for 7 years now, 5 professionally, I had never used eval in any of my applications 🙂

(defmacro time-compiled [] 
  (str (Instant/now)))

basic and perhaps not super-dee-duper useful, but this is a thing you can only accomplish with macros - eval runs at runtime

most macros are either def-like, wrapping up some boilerplate for a declaration of something

(defrecord ABC [a b c])

or with-like, wrapping up some lexical context

(with-open [will-close-when-done (thing)]
  ...)

the more DSL-ey macros that have more complex semantics tend not to survive

but one of my favorite examples of macros is this

(let [name "bob"]
  (>> "Hello ~{name}, how are you?"))

this >> macro expands to (str "Hello " name ", how are you?")

you need to do that as a macro other wise you wouldn’t have name in scope

and its a clear example of something that other languages need to add language features for explicitly, but can be accomplished by a library in clojure

Can you please paste the code as text?

ofcourse

(ns app1.core
  (:gen-class))
; (nth (reverse args) 0)

(defn
  backwards
  "doesn't do much"
  [args]
  (apply str (vec (drop 1 (vec (reverse args))))))

(defn -main
  "I don't do a whole lot ... yet."
  [& args]
  (do
    (println (backwards '(1 2 3 str)))))

this one works

(ns app1.core
  (:gen-class))
; (nth (reverse args) 0)

(defn
  backwards
  "doesn't do much"
  [args]
  (apply (nth (reverse args) 0) (vec (drop 1 (vec (reverse args))))))

(defn -main
  "I don't do a whole lot ... yet."
  [& args]
  (do
    (println (backwards '(1 2 3 str)))))

this one doesn't

Because of the quote, you are passing the symbol str, and not the function that str is bound to in the clojure.core namespace

i thought symbol is the function

so how would i pass in a function

if function is 1st class citizen, i have it in the list, this should mean i can access function inside the list

(list 1 2 3 str)

Well, you can build the list with the function in it. For instance: (list 1 2 3 str)

yup 🙂

So when you do that, str is evaluated as the function that str is bound to

At my repl, this prints as:

(1 2 3 #object[clojure.core$str 0x3241713e "clojure.core$str@3241713e"])

Yeah, I would say using quote, aka ' , is rare in day-to-day Clojure https://clojuredocs.org/clojure.core/quote

If you use ', it quotes everything in the list, including the str

Which prevents it from evaluating str to the function

If you were to evaluate it a second time, it would evaluate to the function

@U02QJVDHHE2 In Clojure, we typically use vectors to store and pass data around rather than lists; that would work right away: [1 2 3 str]

'str evals to the symbol str which then evals to the function

If you ever have a symbol, you can get the function that it’s bound to in a namespace (like clojure.core), but that’s getting more advanced, and unlikely to be what you want to do here. (you can call eval, or you can look up in the namespace)

oh, this works thanks

clearly I'm missing knowledge on the escape characters

thank you all very very much

It’s a little tricky, but honestly, it’s rare for most code to need it

i really appriciate

clarified a lot, once again

really helpful people on this server 🙂

It's more useful for when you get to macros, which clj doesn't push as much as other lisps

i can see why, the functions are insanely powerful

I recommend @U050KSS8M’s advice: use […] for passing around sequences of data. Vectors convert to seqs automatically in most cases

i could just (vector )

same thing right?

You could, but it's longer

Well, that’s what square brackets do for you, and they’re shorter 🙂

i know, I just get carried away to simplify the syntax

The compiler turns it into a call to vector, yes

because with simple () you get to do so much in clojure

it just carries me away 😅

Unless I’m working at parsing or emitting code, then I don’t need lists very much

Also, this is a stylistic advice, but I think it's relevant. Use let for clarity and to showcase the "order" of operations:

(defn
 backwards
 "doesn't do much"
 [args]
 (let [args         (reverse args)
       f            (nth args 0)
       numbers-data (drop 1 args)]
  (apply f numbers-data)))

(defn -main-2
 "I don't do a whole lot ... yet."
 [& args]
 (println (backwards [1 2 3 str])))

Brevity in excess can obscure clarity

i'm using calva and whenever i format, it kinda does it own thing

That’s OK. But the let advice is sound

oooh

I've been doing Clojure since ~2013 and it took me a few minutes to unpack the initial code 🙂

So yeah.

You could also destructure with (let [[f & args] (reverse args)] ...)

But that's getting to more terse and less readable

Also, I advise people who are new to Clojure to learn about macros, but not to use them. I also advise people who have used Clojure for several years to not use macros 🙂

You should know what they are for those few times when you need to use them

And it's very rarely you need them

(Stuart Sierra did a talk about this many years ago: The first rule of macro club: Do not use macros. The second rule of macro club: DO NOT USE MACROS. … the talk went on to give sound advice about how to use macros if you REALLY have to use them)

Yeah... Macros are hard to get right. I would even say that you don't need to worry about them until you have a decent understanding of the entire language. But curiosity is always good.

@U051N6TTC Do you have a link to that talk by any chance? I might have watched it but not quite sure.

There is no video, but the slides are available

Ah, got it. Thanks anyway.

this is better style?

out of curiosity, can i use (vector ) instead of [] for function arguments?

@U02QJVDHHE2 this looks much nicer, yes

When you define a function using defn, you must use [] around its arguments.

When you call a function, you can put whatever expressions you want in the call to send as parameter values.

I see, unfortunate

would be fun to use just the () in entire program

thanks for the answer

Why would you consider it useful to use (vector ...) inside of defn ?

it's not useful, it'd just be ultimately simple, as I'd use symbols and parentheses

Some other Lisp family languages use () consistently everywhere. Rich Hickey knew about that, and explicitly chose to use [] in places like defn and let for readability.

When defining, the defn is a macro so if you tried:

(defn add (vector a b) (+ a b))

i.e. NOT always using () for everything, so there are explicit visual cues that some things are parameter lists in a function definition, or a vector, or a map, and they look different

i agree it's more readable

Perhaps some of the conversation can go back to the main channel, so individual questions can be threaded out?

so, what I'm hearing is, I could make a macro such as (vectorify) , which would evaluate that list to a vector?

which would allow me to use lists for function argument

even though, again, this is by no means useful

I am not sure about that. I think that perhaps a macro is restricted to replace lists with lists.

fair enough

You could define your own macro mydefn that had a list of parameters inside of it, and replaced it with a standard defn with a vector for the parameters.

oh yea, that'd work

thanks

When I say "restricted to replace lists with lists", I meant more precisely that the top level thing returned by a macro must be a list. It can replace "inner lists" with other things.

understood

Would think not? I wonder if you're mistaking Clojure for https://developers.google.com/closure ?

I think the real answer is "it depends" but generally I'd say that you should plan to implement the read parts of the collection interfaces

the clojure collection interfaces?

well certainly the Clojure collection interfaces, but I meant the JDK collection interfaces

okay, cool. thanks

so, I would expect get to work on a map, but much less likely Clojure's impl would ever put (as we don't do that on persistent colls)

you’re talking about .get as an explicit method, right? vs IAssociative’s .entryAt or ILookup’s .valAt

thanks for all the help, i appreciate it

yes was referring to Map.get()

certainly, you should implement the IAssociative / ILookup stuff - you know Clojure will depend on those

it's possible some code may rely on the Java interfaces somewhere, but I can't say I've ever audited for that, for sure things like .iterator() are called

that makes sense

the #(…) form is a concise form of (fn [args] (…)) : https://clojure.org/reference/reader#_dispatch

which is to say, an anonymous function

ah thank you

and fyi, in Clojure 1.11, you'll be able to use parse-long for this

Is the only reason to use #(..) over (fn ...) because it is more concise? I imagine it maybe is more helpful in other contexts - like maybe macro writing - when you need to grab parameters

it's just syntax sugar for more concise fns

Thank you both

@U01188CHUFL This is good reading about the #(..) syntax: https://stuartsierra.com/2019/09/11/clojure-donts-short-fn-syntax

I can cycle the privacy easily enough in emacs just wondering about a more concise way to do it

there’s no shorthand for def.

At a previous job they wouldn’t use defn- but rather defn ^:private so it would mimic the def ^:private

actually that raises a good point; that would make private methods and defs easily searchable

@U01188CHUFL Also worth noting that you can "get around" private in Clojure by using #'some.ns/private.var to reference it -- which bypasses the access check. So ^:private is more "advisory" than, say, Java's private access.

ah I see - I didn't know that. I think that is okay, common lisp is similar in that regard you can use :: to access non-exported symbols in a namespace as opposed to : to access the exported symbols. As long as people know they are being naughty!

Or reverse the arguments:

#(if-not (zero? %) (reset! form-value- %) %)

Ah, I misunderstood. Then it was all good as it was

Perfect, thanks!

or I think this follow's @U051N6TTC's intent - not doing a reset unless the value changes:

#(if (zero? %) (reset! form-value nil) %)

atom operations are expensive

I suggest you tap>, log, or prn the value of target-file there. It's not what you think it is, based on that exception.

@U01GXCWSRMW If I add (println (str "target-file: " target-file)), I get the following output:

target-file: clojure.core$str@6d91790b/Users/dp118m/dev/misc/dpisarenko.com/content/conscience-of-nation/fragments/overview.org

It looks like the str function was prepended to the front of the path. Maybe an extra str that you didn’t need got in where you were building the path?

target-fileis FRAGMENTS_OVERVIEW_PAGEbelow.

(def MAIN_DIR "/Users/dp118m/dev/misc/dpisarenko.com/content/conscience-of-nation/")

(def FRAGMENTS_DIR (str str MAIN_DIR "fragments/"))
(def FRAGMENTS_OVERVIEW_PAGE (str FRAGMENTS_DIR ""))

👍

if you don't write clojure like

(defn foo [bar]
   (frob bar nil
    )
)

function foo
  (bar)
  {frob(bar null);};

(to be less snarky, it helps readability / mutual understanding if we use coding conventions native to the language we are writing, and we don't do hanging ) in clojure)

I actually had to double check that even worked 😆

> function foo
... (bar)
... {console.log(1 + bar);};
undefined
> foo("help");
1help
undefined

See https://github.com/technomancy/leiningen/blob/master/doc/TUTORIAL.md#checkout-dependencies

this was a driving force behind our switch to deps.edn its a bit easier there

{components/abc {:local/root "../../components/abc"}}

I've tried checkout but it doesn't work, perhaps because i'm on windows

all i did was a shortcut, may not be same as a link on linux

@U02QJVDHHE2 When you have time look into using clojure deps so you can take advantage of the logic emccue is pointing out above.

if I'm not working on both projects in parallel, the thing I've found easiest is running lein install in the lib project, then adding it to the other project as a normal dep

the gotcha with lein install is you need to remember that projects that use libs installed that way won't work on other computers (and the version installed and your latest edits can go out of sync)