hello folks, anyone knows how to print a function name in clojurescript for browser? name and var won’t work.

interestingly, (.toString function-x) prints the whole function code whereas i’m only interested in its name (for logging)

(defn fn-name [f]
  (demunge (.-name f)))

@michael.heuberger if you just want to log it then why not just quote the function. (.toString (quote func-name))

thanks guys, will check out both suggestions after the weekend (new zealand here)

Hello, just wondering if there was some article I could read about best practises around where to put files in your clojure/clojurescript project. Like where do I put cljs, cljc, clj. I just want to read an article because I'm bad at making up my mind 🙂

@djwelch666 I just keep everything in src/main which already "group" everything by namespace. no need to group by extension.

@djwelch666 I do have src/cljs, src/clj and src/cljc, because the frontend and backend don't have much code overlap. mixing them is not impossible but not very positive either (in my case)

I have seen src/cljs, as well as src-cljs. I guess there is no real difference

personal preference really

yeah, cheers

Does anybody else develop a shared react / react-native app here? How do you handle differences? reader - features seem to be out for this use case ...

@bendlas you may not be able to share that much actual UI code

Sharing actual functions between react-dom and react-native is not a primary goal of RN AFAIK

But of course you can share all the helper libraries

Chances are your native UI will be different from the Web UI

OK, please get me right, I'm not looking for basic answers, I've been developing with Cljs for several years, and I think I had one of the first commercial applications out with it ...

my current application is in production already ..

with web and native developed separately

Yeah as I see it the question poses itself for React (JS) as well as for CLJS

our primary use case is sharing sharing functionality. sharing ui code is a secondary / non - goal

The answer will be pretty similar — separate code into platform-specific and shared business logic

that's what we've been doing

I've been working on shared react-native and react-dom code bases for a few years, so if you have more specific questions lmk

but i want a solution for almost-equal namespaces, that have different :require clauses. everything else is pretty much taken care of

ah

the best, I've been able to do, is create separate source folders

possibility 1: two source directories with different classpaths

but it just sucks being back to pre-cljs for this

@dnolen has declined my ticket due to missing previous discussussion: https://dev.clojure.org/jira/browse/CLJS-2396

possibility 2: write code in such a way that it doesn't blow up at NS init time

e.g.: (def react (if (on-react-native?) (js/require "react-native") (js/require "react-native-web")))

and the list conv doesn't seem to be going anywhere https://groups.google.com/d/topic/clojure-dev/8YJJM8lJuQs/discussion

avoid things like (def platform-specific-comp (r/adapt-react-class js/PlatformSpecificComp))

@pesterhazy I'm doing 2) as much as possible, but it's not for require clauses

@bendlas nothing was missed in declining that ticket

if Clojure doesn’t support that we’re not going to support it, end of story 🙂

@dnolen it was a statement of fact, not an accusation ...

if the "require"s in the ns declaration blow up because of missing npm deps, avoid those in favor of using js/require directly

@bendlas sorry I think I misread what you were saying

you can build shared RN / react-doc namespaces that way

I see now you were saying that you had missed the Clojure discussion on this matter

@pesterhazy yeah, that's what I'm doing anyway, since too much read-cond gets confusing as well

but at least the entry point still needs to be overlayed from separate source directories then ...

@dnolen how do you feel about making the reader in cljs swappable? that's not something we would need to wait on clojure for ...

no

I think we should just leave reading alone

so you're telling me, that I would, in fact, need to do significant development work, in order to feed data structures to a lisp compiler (and cover all the tooling cases)?

that's easy to say, if you don't have a need ...

I’m not suggesting anything except not interested reader stuff

whatever problem you’re trying to solve I do not have context for

but I also know other people have likely encountered this problem and worked around it without futzing with reader capability

multiple source-dirs for multiple entry points has worked well for me in the past

which probably what JS people do

different builds - it’s not a big deal

I'm doing different builds, and probably every "best practice" for clojurescript

this still is a real need

I suggest taking this to #cljsrn and collecting more information

I don’t really have anything more to say on this for now

re the reader, the concern from Rich from the beginning was to avoid creating Clojure(Script) code that is unreadable by other users. Being able to swap out the whole reader would open that scenario so I don’t think Rich would be on board with that.

same reason we don’t have reader macros

Yep, I'm aware of that concern

@bendlas the goal here should be distill the problem and not jump to the solution

futzing with reading is one way

I still think it could be easier to use just the compiler (with a custom reader) without making that problem worse

but I’m not really hearing other options - so it’s easy to be disinterested

I understand the pain people are encountering here - but it’s same pain in any programming language

when you’re trying to target multi-platform in some generic way

anyways far as I’m hearing this is only about imports

so why such a big hammer for such a well defined problem

I cannot understand this at all

> it’s same pain in any programming language

this is (one of) the reason(s), I like using clojure over other languages

because it's less pain

anyways Slack is not the place for this - come up with a proposal with multiple ideas

and suggest it on the usual channels instead of pursuing only reading as the way

> so why such a big hammer for such a well defined problem to be fair, what other problem did read-cond solve for clojure?

I will certainly look it over such a proposal, provide feeback and see if I have further comments/ideas

but I agree w/ your assessment that I’m not worked about it because I don’t need it

but even if I did, I don’t have issues w/ managing the classpath, writing some redundant files or whatever

@dnolen I'll try to come up with something, but there are only so many eyelet to hook into

and classpath overlaying just sucks. not least because of the confusion it causes

fwiw I already had this discussion with Rich and our conclusion was that managing the classpath was fine in many cases

That got massively better with cljc

I don’t really believe that

since you need to manage the classpath all the time already

build vs dev vs test vs whatever

which suggests this case is not really different in any meaningful way

all the cases i've been finding could be solved with distinct namespaces. the best solution for this one seems to be overlaying namespaces ...

well, I guess I'll be looking into shadow-cljs, until more users become vocal on this, and / or someone on the core team has a personal need 😉

yes, shadow-cljs does lots of cool things we’re not necessarily interested in (yet) - so this seems like a perfectly fine solution to me!

yep, maybe there's a chance to enhance its tooling support as well ...

@dnolen @alexmiller I'm just looking at the latest State of Clojure, because I want to know, how many people are doing what I'm doing (shared web/native). Didn't find anything about that ... do you have any idea about that?

no we might want to start asking that question

I do suspect shadow-cljs usage to get a huge boost in the next survey given the large influx of JS users

and the fact that Google Closure NPM integration is challenging / slow going

there was one question about targeting React Native I think ?

that may very well trigger us adopting a similar strategy but with our own spin

yeah, 19.5% said they were targeting React Native

but just not feeling rushed - there’s already tons of users and legacy code bases doing things the previous way

I can see this being dirty the solution bendlas is suggesting with the reader. Offering no solution, but I could see how seperating native platforms would be nice. I'm now working with Samsung Tizen and Amazon FireTv, they both offer custom chromium browsers that can do some custom stuff. Never did rn, so not sure if it's comparable 🙂

I'm trying to compile a minimal program with the cljs.main and target node. It does not work. Am I doing something wrong? https://github.com/lgrapenthin/cljs-main-node-problem

@leongrapenthin you need to specify "-re node"

And you can skip the --output-to

This is what I use

{:deps {org.clojure/clojurescript {:mvn/version "1.10.238"}}
 :aliases
 {:prod
  {:main-opts ["-m" "cljs.main"
               "--optimizations" "simple"
               "-o" "compiled-prod.js"
               "--compile" "foo.prod"]}
  :watch
  {:main-opts ["-m" "cljs.main"
               "--target" "node"
               "-o" "compiled-dev.js"
               "--watch" "src"
               "--compile" "foo.devserver"]}
  :repl
  {:main-opts ["-m" "cljs.main"
               "--repl-env" "node"
               "--repl"]}}}

oh wait

@pesterhazy nice

you dont' need -re

@bhauman But I don't want a repl environment

yes

yeah my mistake

it was the http error that was throwing me

I'm not using clojurescript to pull in NPM deps. Instead I just add them to package.json (and yarn install). To make that work from the repl I use NODE_PATH="$PWD/node_modules" clj -M:repl

since i'm using exactly the command line from the quickstart i'm wondering if I'm doing sth. else wrong

@leongrapenthin not sure if that will work without master

there was a bug about requiring Node.js core modules that was addressed if I recall

@dnolen thanks, I'll try master

@dnolen can confirm its working on master

@pesterhazy if you are watching you may want to try figwheel.main https://github.com/bhauman/lein-figwheel/tree/master/figwheel-main

I could use some field use feedback

@bhauman just playing around with it myself

I get Exception in thread "main" clojure.lang.ExceptionInfo: Couldn't read the file:figwheel-main.edn {:figwheel.main/error true}

@dnolen what args?

no args?

what’s in your README

nothing different

clj -Sdeps "{:deps {com.bhauman/figwheel-main {:mvn/version \"0.1.0-SNAPSHOT\"}}}}" -m figwheel.main

oh cool thanks

need high level testing which is much easier now

I’m looking forward to taking this for a serious spin

being able to compose dev stuff in ~/.clojure with project local stuff is so much better

oh yeah it is

@bhauman looks cool, I'll check it out

another thing is it's even better in leiningen

the main stuff?

yes

yeah I believe that

no dynamic loading of plugins so its faster

but also much more expressive

rock

for node I'm just using doall clj -M:watch -- nodemon dev-compiled.js, where doall is https://gist.github.com/pesterhazy/9020617ade9c93c3cccd9748f76dbe01

it just restarts the node process whenever the cljs compilation produces a new output file

it's useful to bundle everything into a single script that you can ask people to run

whereas figwheel hot loads it into the running program

depends on what you are developing

right for the browser where you have a lot of state hotloading is obviously superior. I'm excited to give it a try next week

can anyone recommend a library for dealing with in-memory graph-like data in clojurescript?

basically i have a list of nodes and and edge descriptions, and need to run some simple queries on it, such as “how many steps from node A to node E”

most of what I’m finding via google or clojars requires the JVM

maybe I can use datascript for this

@mattly tree-seq is an interesting tool for this

a tad challenging to initially get used to but makes for some concise solutions

thanks – man core is huge

@mattly: I use ubergraph (datastructure for various types of graphs + some algorithms). https://github.com/Engelberg/ubergraph Not sure it runs on clojurescript

I looked at that one already, it doesn’t. thanks though

it turns out my data structure has circular directed references as well

so most libraries probably wouldn’t be of help anyway

https://twitter.com/borkdude/status/1002623954320871426

I was super impressed with blessed at first but ran into a few bugs that were kinda dealbreaks 😕 specifically made it hard/impossible to use lists in react-blessed

https://github.com/chjj/blessed/issues/325 the project seems mostly unsupported

@lilactown cool, I’ve only been playing around with simple examples so far

@lilactown this project seems pretty active though: https://github.com/yaronn/blessed-contrib it lists blessed as a dev-dependency, wonder why it isn’t a normal one

does anyone know if with-open is supported on clojurescript?

any other way to get the same functionality if not?

@johanatan it doesn’t seem so, but you can include the macro in a .clj file and then use it from clojurescript?

@borkdude do you have an example of that? I generally avoid macros in cljs due to not having successfully pulled that off before

@johanatan in which context do you use cljs?

lumo repl + src and jar classpaths

[currently]

@johanatan ok, here’s an example: https://github.com/borkdude/balcony/blob/master/lumo/src/balcony/env.clj

@borkdude cool, thx!

this is using self-hosted cljs. I don’t know in detail how it works with macros, but this one worked…

hmm, so the only diff is the file extension?

lumo processes clj files as clojure?

@johanatan https://github.com/anmonteiro/lumo/issues/377

> We currently only look for macros in .cljc and .clj files (see

I think that’s a good choice, principle of least confusion

@johanatan you could maybe use https://nodejs.org/api/stream.html

@selfsame i'm looking particularly for the resource cleanup/finalization. with-open just calls .close() on its target (which could be impl as a protocol method)

@johanatan transducers are maybe even better for closing stuff when you’re done reading. with-open doesn’t play nice with laziness

oh maybe just grab the macro from https://github.com/clojure/clojure/blob/clojure-1.9.0/src/clj/clojure/core.clj#L3797

@borkdude in my case, the cleanup would be: (fs.unlinkSync temp-file) (the resource acquisition is the equivalent of mktemp from bash).

@johanatan example for processing text files using a transducer: https://blog.michielborkent.nl/blog/2018/01/17/transducing-text/

ah, good to know but doesn't really apply in my case. the file is created in one fell swoop via output redirection to a temp file and it's read in its entirety on the very next line via readFileSync

what should your code look like?

(with-open [f (mktemp!)]
    (sh (str "some-process >" f))
    (do-stuff-with (fs.readFileSync f "utf-8")))

ideally

[assuming that sh exists and does what one would expect

likewise for mktemp

so it should be something like with-temp which deletes the temp file?

yea

I have one of those in JVM clojure laying around

note that regular with-open is not what you want here

well, i was thinking that i could use with-open to implement with-temp

probably just a (try (do-stuff) (finally (.close f)))

i.e., with-open according to docs doesn't call .open and only just calls .close() when finalized

(defmacro with-tmp-dir
     "Evaluates body while binding `tmp-dir-bind` to a fresh temporary
  directory and returns evaluated value. Cleans up directory
  afterwards, if no exception happens. Else, leaves it there for
  inspection."
     [tmp-dir-bind & body]
     `(let [~tmp-dir-bind (new-tmp-dir)
            res# (do ~@body)]
        (org.apache.commons.io.FileUtils/deleteQuietly
         ~tmp-dir-bind)
        res#))

@selfsame yea, i could implement it that way

like so:

(defn with-temp [callback]
  (let [tmp (mktemp)]
    (try
      (callback tmp)
      (finally
        (fs.unlinkSync tmp)))))

if with-open existed, i could have implemented it via defining a close however

[in probably 1-2 lines]

@johanatan I wouldn’t try to retrofit things into with-open if you can do it more simple

yea, i'm inclined to agree since it isn't readily available. if it were [easily] available however, it would be tempting 🙂