I'm just trying to check a couple of booleans. 😅 (js-in test-value (j/obj actual-value true))

Well ... this works ... not sure if it's recommendable 🙂

(let [a 42
      b 43] 
    (js* "a == b"))

Ah beautiful. That's got to be better than what I was doing.

I wonder if those vars will survive advanced compilation though.

Good call ... I'd say no 😄

Even :simple renames local vars as far as I remember.

But apart from that, I'm not sure from your example what you're trying to achieve - what does the j/obj part do?

Ah sorry, that's applied-science.js-interop and it just creates a JavaScript native object like #js .

What I am trying to achieve is miniscule build sizes using shadow-cljs for a small piece of front-end code. Will do a blog post about this.

At the moment my build size is 640 bytes to add a little bit of on-page interaction. I still get to use cljs syntax and tooling like shadow-cljs live reloading.

Hm, still not quite following - where does the usage of the == operator come in? I assume you need the specific js-semantics in some way, like 42 == "42" evaluating to true?

The problem is if you use Clojure's = operator the size of the build balloons out to 94kb.

I would prefer to do a very simple equality check on two booleans and keep the build at 630 bytes.

Sounds like a nice goal... but then it will behave like the JS == operator... ;)

I went hunting in the cljs source to see what happens in cljs.core/=. As far as I can see it calls out to identical? which calls itself? I'm not sure I understand that ...

https://github.com/clojure/clojurescript/blob/master/src/main/cljs/cljs/core.cljs#L232

What would be good is js/== or js-equals. Maybe I should submit a PR. :thinking_face:

But how would that be implemented?

Ah, identical? the function calls identical? the macro: https://github.com/clojure/clojurescript/blob/9359f40e7537307b9272fd322ae5cfff88e079f2/src/main/clojure/cljs/core.cljc#L998

Which seems to use the js* == trick ... Since it's a macro, I assume it will then survive advanced compiling? :thinking_face:

Not sure how js* is implemented, but if it emits javascript before the Google Closure compiler is invoked, I'd expect everything to work

Worth noting that you are probably looking for === and not ==. The == operator gives you automatic coercion semantics that probably have nothing to do with your described goal, while === tests for strict equality.

if you do want coercive equality (`==`) looks like cljs.core has you covered https://github.com/clojure/clojurescript/blob/9359f40e7537307b9272fd322ae5cfff88e079f2/src/main/clojure/cljs/core.cljc#L911

(coercive-= "" 0)
=> true
(coercive-= "" false)
=> true

the js* form is handled in the analyzer here https://github.com/clojure/clojurescript/blob/9359f40e7537307b9272fd322ae5cfff88e079f2/src/main/clojure/cljs/analyzer.cljc#L3694 and emitted in the "compiler" here https://github.com/clojure/clojurescript/blob/9359f40e7537307b9272fd322ae5cfff88e079f2/src/main/clojure/cljs/compiler.cljc#L1434 pretty straightforward pass-through to the output js

@U051V5LLP ah thanks so much for this!

finally I solved the problem: https://github.com/temanmd/clojure_learning_foobar/blob/main/src/foobar/backend/routes.clj#L17

Thought about it, but Typescript is native for AWS, comes with code-completion etc which is very handy and CDK is really all about making objects so better suited.

this awesome book should help with that https://funcool.github.io/clojurescript-unraveled/#core-protocols-section

Thanks!

This is exactly what I was looking for.