hello, yes, there’s some examples around this in https://github.com/nextjournal/clerk/blob/471c270f492f3d9ffa427aeaefe29a375770c8b4/notebooks/viewers/code.clj

thanks!

works out of the box. thanks a lot!

Yeah you have the full SCI environment available

https://github.com/mentat-collective/clerk-utils/tree/main/resources/clerk_utils/custom

(def source-files "")

(defn args->call [f args] (conj (seq args) f))

(defn make-public-fns-table
  [ns]
  (let [publics (->> (ns-publics ns)
                     (map (comp meta second))
                     (sort-by :name))]
    (clerk/html
     [:div (for [{:keys [name file macro arglists doc line const]} publics
                 :when arglists]
             [:div {:class "pb-8"} ;; add border
              (clerk/html [:span [:b {:class "underline decoration-2 decoration-sky-500"} name]
                           [:sup [:a {:href (str source-files file "#L" line)} "  [source]"]]
                           (when macro [:sup " MACRO"])
                           (when const [:sup " CONST"])])
              [:p]
              [:div (for [args arglists]
                      (clerk/code (args->call name args)))]
              [:p]
              [:div (clerk/md (str (or doc "\n")))]])])))

(make-public-fns-table 'fastmath.core)

And the result:

Amazing, would love to have support for the [[links]] here too

Yeah, working on that, it's possible without too much effort I think.

Constants also work (and codox MathJax formulas embedded in docs)

@U017QJZ9M7W got it:

and the final code snippet

Amazing

(def source-files "")

(defn args->call [f args] (conj (seq args) f))
(defn fix-tex [s]  (str/replace s #"\\\\\(|\\\\\)" "\\$"))
(defn fix-anchor [s] (str/replace s #"\[\[(.+?)\]\]" "[$1](#LOS-$1)"))

(defn make-public-fns-table
  [ns]
  (let [publics (->> (ns-publics ns)
                     (sort-by first)
                     (map second))]
    (clerk/html
     [:div (for [v publics
                 :let [{:keys [name file macro arglists doc line const]} (meta v)]]
             [:div {:class "pb-8" :id (str "LOS-" (clojure.core/name name))} ;; add border
              
              (clerk/html [:span [:b {:class "underline decoration-2 decoration-gray-400"} name]
                           (when macro [:sup " MACRO"])
                           (when const [:sup " CONST"])
                           [:sup [:a {:href (str source-files file "#L" line)} "  [source]"]]])
              [:p]
              (when const [:div (clerk/code (var-get v)) [:p]])
              (when arglists [:div
                              [:div (for [args arglists]
                                      (clerk/code (args->call name args)))]
                              [:p]])
              [:div (clerk/md (->> (or doc "\n") str fix-tex fix-anchor))]])])))

https://generateme.github.io/fastmath/notebooks/notebooks/random.html#list-of-symbols

If you have them in clojure var they are inlined in html afair.

alright, thanks!

@U050AACJB some bad helper code I've made for doing line and line/ribbon charts https://gist.github.com/otfrom/2785ab6767d2e887d6f44e357b968f9f (don't know if this is what you need or not)

@U0525KG62 thanks! I don’t even know what ribbon charts are, but I’ll study your code closely as I’m just starting out with clerk!

axes and legends clipped to protect clients. This was tricky due to how vega handles legends

oh these look nice

I do lots of summarising simulations w/medians iqrs 90% ranges

tc/tmd make it a lot of fun

and now I can actually do the charts I need in vega-lite

(thx to @U04JZRX0GV7 for figuring out how to do it)

all to be published eventually but still alpha and changing too much atm

I have stuff that takes too long to run (10+ minutes) so I think I’ll isolate these in namespaces that clerk doesn’t watch and use the workbook namespaces for the lighter results exploration/viz part of the job

yeah, you can always build the notebook off the output of the longer running things

tho there might be way to make the longer running things go faster 😄

not if it’s 1000 requests to a 3rd party service 😅

ah, no, not that really 😄

> I have stuff that takes too long to run (10+ minutes) so I think I’ll isolate these in namespaces that clerk doesn’t watch and use the workbook namespaces for the lighter results exploration/viz part of the job (edited) I was in a similar situation some time ago -- loading lots of usage data from https://www.sanity.io/ to analyze what kind of usage we had over the last few years. I tried using Clerk for everything at first, but wan't happy with the performance. Randomly having to wait a minute or two for the first clerk page load wasn't too nice! I ended up with a solution similar to yours -- splitting the "load all the data" code from "analyze it", and was really happy with that. Pulled out the "load all the data" code as a function I could execute with clj -x my.stuff/load-my-data. Then the clerk notebooks read that data from disk, and were snappy and easy to work with. It was also really nice to have a clean separation between raw data and "the data in the shape that I'd like".

That’s nice, and saving to disk is something I also ended up doing. Was the load-my-data part a long doseq?

yup! Something like this:

(doseq [y (range 2019 2023)]
  (print "Dumping transactions for" y "...")
  (dump-transactions-year! y)
  (println " done!"))

I’m thinking about how long running jobs like that could be monitored on a personal REPL level (rather than monitoring in a production deployment which is a solved problem).

oh, gotcha. For me, downloading all the data took about a minute, so perhaps less than you have to deal with. Splitting the data into chunks so that (A) each chunk was quite fast (seconds) to download, and (B) was stored in its own file helped a lot for me. I had lots of data like this:

data-dump/DOMAINTERM-2019.edn
data-dump/DOMAINTERM-2019.json
[...]

There might be better solutions -- I didn't spend more time than I needed to. I was more curious about what I could learn from the data than the downloading itself.

Yeah doesn’t sound like you needed anything more sophisticated than that! I have a more granular list of items