The Further Adventures of Starting a new ClojureScript project in 2022

borkdude · August 13, 2022, 11:37am

I have a branch of cherry here which emits “direct” JS without the immutable stuff.

What I’ve done:

keywords are mapped to strings
map notation maps directly to js objects
vector notation maps directly to js arrays
assoc! and dissoc! map to in-place mutation of js objects
keys destructuring works (emits more boilerplate than needed, could emit spread operator directly)

Demo in this tweet

Examples:

borkdude/cherry/blob/mutable-js-poc/corpus/mutable-js/argparse.cljs

(ns argparse
  (:require
   ["argparse" :as argparse :refer [ArgumentParser]]))

(def parser (ArgumentParser. {:prog "example.cljs"
                              :description "Example!"}))

(parser.add_argument "-f" "--foo" {:help "foo bar yolo"})

(def args (js/process.argv.slice 4))

(js/console.log (parser.parse_args args))

github.com

borkdude/cherry/blob/mutable-js-poc/corpus/mutable-js/fn.cljs

(ns fn)

(defn foo [x y z]
  (let [x (+ x 10)]
    [x y z]))

(prn (foo 1 2 3))

(def x (assoc! {} :foo 1 :bar 2))

(prn x)

(defn bar [{:keys [a b c]}]
  [a b c])

(prn (bar {:a 1 :b 2 :c 3}))

(let [[x y z] [1 2 3]]
  (prn (dissoc! {:x x :y y :z z} :x)))

This file has been truncated. show original

The code could be more optimized by inlining assoc! and dissoc! behavior which can be accomplished by making those macros.

I’d be happy to pursue this further if it seems promising enough

Edit: I now published this to NPM: cherry-cljs@0.0.0-mutable-alpha.53