Can anyone recommend a simple way to evalue a user generated expression within my CLJS app (e.g. eval but sandboxed). An interpreter is fine really - not super worried about performance. I see references to cljs.js and also borkdude/sci which sound like candidates. Not familiar with pros/cons of different approaches.

Use case is to allow user configured behaviour of single page webapp without recompiling frontend. (e.g. setting component properties based on simple formula)

cljs.js is not sandboxed at all

if the language is very restricted I would probably just consider writing your own interpreter

@olivergeorge yes, that is one of the use cases of sci. It’s also used by Chlorine/Clover for configuration

Thanks guys

How do I use react from cljs? I'd like to use react/useEffect, but importing react with ["react" :as react] ;; shadow-cljs gives me this error in the developer console:

env.cljs:198 error when calling lifecycle function mount-components Error: Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
1. You might have mismatching versions of React and the renderer (such as React DOM)
2. You might be breaking the Rules of Hooks
3. You might have more than one copy of React in the same app

are you using useEffect inside of a defn?

Yes.

@endrebak85 how are you rendering the function component that calls useEffect?

are you using a React wrapper like reagent?

I am rendering it in hiccup like this: [render-function-from-example].

I am using reagent in my code, yes 🙂

you cannot use React hooks inside normal reagent components

Understood, thanks.

those get turned into classes. and the warning "Hooks can only be called inside of the body of a function component" speaks right at that

here's how to use React hooks in reagent: https://github.com/reagent-project/reagent/blob/master/doc/ReactFeatures.md#hooks

if you're using reagent 1.0 or above, you can render your component like:

[:f> render-function-from-example]

Thanks, now it works :)

I was advised to use useEffect to be able to update DOM elements with D3 graphs after the DOM elements had rendered. I think I am close, but that I am making a mistake here:

(defn graph-page []
  (let [[graph set-graph]
        (react/useState ;; the state is a dagre graph
         (-> (dagre/graphlib.Graph.)
             (.setGraph (clj->js {}))
             (.setDefaultEdgeLabel (fn [] {}))
             (.setNode "hi" (clj->js {:label "hi" :width 144 :height 100}))
             (.setNode "ciao" (clj->js {:label "ciao" :width 144 :height 100}))
             (.setEdge "hi" "ciao")))
        render-graph (fn [graph] ;; this renders the graph with dagre-d3
                       (js/console.log "render-graph is executed!")
                       (let [renderer (dagre-d3/render)
                             svg (d3/select "svg")
                             inner (-> svg
                                       (.append "g"))
                             _ (renderer inner graph)]))]
    [:div
     [:svg]
     [:button {:on-click #(set-graph (render-graph %))} "Graph!"]]))

A most trivial item of trivia, but: I was rather surprised to find that defprotocol evaluates to false. I had a quick look at the GitHub docs and the last line of the defprotocol macro is a (set! ~'*unchecked-if* false), so I guess that’s it. What should defprotocol evaluate to?

@cassiel that expression is really a hint for the compiler

hi, @dnolen https://www.reddit.com/r/Clojure/comments/mcce4h/everything_i_have_learned_i_have_learned_from/ "29:36 - is source code for this available anywhere ?"

would ask @dnolen

@rafal.wysocki in core.match

funny story I think someone from Apple was there and at least some of that paper ended up in the Swift pattern matcher?

Also funny story: I shared the core.match literature with someone which almost turned into a thing to optimize state machines in Yosys, but I don't think it was ever completed.

Is there a way to tell if we're in the Clojure cljs macroexpansion stage vs just regular Clojure? Here's my motivation: I have a log util namespace util.clj with macros like

(defmacro logp
  "Impl for log macros. Log `args` at `level`."
  [level & args]
  (macros/case
    :clj
    `(clojure.tools.logging/logp ~level ~@args)

    :cljs
    `(js-logp ~level ~@args)))

(defmacro logp
  "Impl for log macros. Log `args` at `level`."
  [level & args]
  (when-not *clojurescript-macroexpansion*
    (macros/case
      :clj
      `(clojure.tools.logging/logp ~level ~@args)

      :cljs
      `(js-logp ~level ~@args))))