Is there a more pure way to learn web development with CLJS rather than Luminus? I feel like starting with no framework at all will better teach me how to fit components but I'm not sure which guide/book teach that?

Coincidentally someone just posted on reddit something similar to what I'm asking for: https://www.reddit.com/r/Clojure/comments/dnwldr/a_series_of_tutorials_on_creating_a_fullstack_app/?utm_medium=android_app&utm_source=share But still if you have other options please mention.

I there a way to integrate clojure.spec/check and clojure.test.check/defspec or use defspec tests within spec :fn? I don't want to duplicate some property tests in my test file and some in my s/defspec

@arto.eg I did https://www.learnreframe.com/ and found it pretty good. There's also a re-frame one that I'm in the middle of.

(this is pure cljs, no clj only)

Could someone point me to a guide/tool that I can use to package a bunch of .css files in a webjar please ?

I used juxt/pack and depstar but they both copy files directly into the jar and not under META-INF directory

which is what is apparently required by webjars

@hosiawak add a META-INF prefix to your files.

META-INF is just a folder

Eg src/META-INF/foo.css

(There's an undocumented api in pack that could be used to do remapping, but I've not opened it up really. There's not a lot of good in doing clever things with packaging)

@dominicm so I need to use a shell script to copy these files into a META-INF directory and then call pack/depstart to package that dir as a jar or is there a tool in Clojure that I can use to do this ?

here's an example webjar pom.xml file: https://github.com/webjars/bootstrap-sass/blob/master/pom.xml#L53-L54

what do they use to process this ?

Anybody else getting backend unavailable from http://repo.clojars.org?

Just started working again, sorry for the spam 😁

Do folks tend to alias clojure.string as str or something else?

We use s

i like str my work likes string

str. I reserve s for spec.

https://stuartsierra.com/2015/05/10/clojure-namespace-aliases life is so much better with this convention having each ns define its own DSL (custom aliases) for refering to other ns'es seems a pretty superfluous barrier for understanding other people's code

templating engines for serverside html ... favorites? currently using rum for cljs and the clj templating, but i'm wondering if there's more mustache-like versions i could be relying on.

string because why is it special and gets to be str? (Also Stu's thing above)

because it is special and gets to be str. 🙂

I like it as string but then I always prefer a real word over a shortened or acronym when reading code

what makes it special though? 😄

I don’t like str as an alias because there’s a frequently used core fn named str

if you just use the methods on String you don't have to have arguments about namespace aliases

can core.match guard/when patterns work across two matched values? this is incorrect syntax but should explain what I have on my mind:

(match [state event]
       [{:limit x}
        {:amount y} :guard (< x y)]  (do-something x y)) 

woot thanks @seancorfield

I haven't used Django much

Thanks for the thoughts on aliasing all! Solid arguments all around.

does anyone know a “guide/tutorial” out there to create a clojure project that has both Java and Js code ? It seems there are lots of guides for each part but not for both together which makes me a bit afraid 😅

(-> 1 ((partial = 1))) => true. What’s the elegant way of doing it without inner parens?

(->> 1 (= 1)) ?

no, I get that… ah. maybe need better example

Is this in the middle of a threading pipeline, and you just want "end of args" in this one slot?

(-> 1 ,,, (->> (= 1)) ,,,)

the as-> macro is great for inserting into the middle of a list of -> invocations (`->>` also works if it happens to be you want it last)

I’m just looking for equivalent of (), e.g. (-> 2 ((comp + -))), how to do this without inner parens?

it’s not apply, it’s not eval, what is it?

you’re looking for the behaviour where the threading macros insert () for you as a convenience like (-> 1 inc) but for a more complex expression like (comp + -)?

yah, something like that

it does not exist. if the expr in a threading macro is a list then it will not insert the ()’s for you

is a list at macroexpansion time I guess

@ag -> is a purely syntactic transformation. Hence our suggestions to use ->> or as-> in the middle of ->.

yeah, I’m just surprised there’s no equivalent to () as in funcall (not as in “unit”, empty list)

but just like I was surprised that time when I found, there’s not equivalent of Haskell’s flip function in clojure.core, and soon I learned that you don’t really need it. Probably if that doesn’t exists, it’s not needed

What syntax and behavior are you thinking of for () that is not provided by (apply foo) ?

you can’t do something like this (->> 42 (comp foo bar baz) apply)

Maybe I am too steeped in what -> and ->> do to understand.

yeah, that doesn't make sense

I think it would be clearer with a stepped expansion of ->>

I am guessing you are not hoping that (comp foo bar baz 42) does something useful?

Is there a way to try something like (slurp *in*) using the REPL?

Oh, maybe you were wishing that ->> would somehow figure out on its own that (comp foo bar baz) is a function as a whole, and not stick the 42 inside there?

It's not that much of a mind-reader.

so these are equivalent, right:

((comp clojure.string/upper-case name) :foo)
(apply (comp clojure.string/upper-case name) [:foo])
(->> :foo ((comp clojure.string/upper-case name)))

you cannot

All of them are absolutely needed

because ->> is syntatic, not semantic

How do you do (+ 5 7) without the parens? 🙂

->> doesn't know what the value of the things it manipulates will be after evaluation

->> only knows what they are after reading

so it can't test "is this a function"

it can test "is this a list? is this a number?"

which is the syntax/semantics division, ->> can manipulate objects of syntax (what is read), not semantics (evaluation being the determination of meaning)

I mean, one could write their own variant of ->> that at run time determined whether each of the expressions returned a function or not, but if you tried to do that, the expressions would have to be evaluated, and they would be missing a parameter, and attempt to call the wrong arity.

Haskell has syntactic currying of function calls always, everywhere. Clojure doesn't. Not sure if that is what you might be thinking of.

This is just a workaround, but perhaps a practical one:

(let [f (comp clojure.string/upper-case name)]
          (->> :foo f))
;; => "FOO"

and a good illustration of the syntax vs. semantics difference

you changed the syntax so ->> is passed the literal symbol f, instead of a list of symbols, even though those things have the same meaning

Yeah, which is equivalent to the version of that with (->> :foo (f)). The version you wrote can only dispense with the parens around f because ->> and -> have a special case for expression that return false for seq?

Yeah, I guess some always add the parens (f) as a matter of style, to avoid that special case.

so what is happening to comp within a thread macro, why for example this works:

(->> :foo clojure.string/upper-case eval)

(->> :foo (comp clojure.string/upper-case name) eval)

in both cases the second thing is a function, but why do they work differently?

It really is syntactic. In the second case it inserts :foo before the closing paren ... name :foo)