Instantly share code, notes, and snippets.

@taylorwood /core.clj
Last active Nov 28, 2018

Embed
What would you like to do?
GraalVM polyglot interop between Clojure and JavaScript
(ns polydact.core
(:import (clojure.lang IFn)
(org.graalvm.polyglot Context Value)
(org.graalvm.polyglot.proxy ProxyArray ProxyExecutable ProxyObject)))
(set! *warn-on-reflection* true)
(comment
(do
(def context
(.build (Context/newBuilder (into-array ["js"]))))
(defn ^Value eval-js [code]
(.eval ^Context context "js" code)))
(.as (eval-js "Number.MAX_VALUE") Object)
;=> 1.7976931348623157E308
(type *1)
;=> java.lang.Double
(.as (eval-js "[{}]") Object)
;=> {"0" {}}
(.as (eval-js "[{}]") java.util.List)
;=> ({})
#_cool!)
(defn- execute
[^Value execable & args]
(.execute execable (object-array args)))
(declare value->clj)
(defmacro ^:private reify-ifn
"Convenience macro for reifying IFn for executable polyglot Values."
[v]
(let [invoke-arity
(fn [n]
(let [args (map #(symbol (str "arg" (inc %))) (range n))]
(if (seq args)
;; TODO test edge case for final `invoke` arity w/varargs
`(~'invoke [this# ~@args] (value->clj (execute ~v ~@args)))
`(~'invoke [this#] (value->clj (execute ~v))))))]
`(reify IFn
~@(map invoke-arity (range 22))
(~'applyTo [this# args#] (value->clj (apply execute ~v args#))))))
(macroexpand '(reify-ifn v))
(defn proxy-fn
"Returns a ProxyExecutable instance for given function, allowing it to be
invoked from polyglot contexts."
[f]
(reify ProxyExecutable
(execute [_this args]
(apply f (map value->clj args)))))
(defn value->clj
"Returns a Clojure (or Java) value for given polyglot Value if possible,
otherwise throws."
[^Value v]
(cond
(.isNull v) nil
(.isHostObject v) (.asHostObject v)
(.isBoolean v) (.asBoolean v)
(.isString v) (.asString v)
(.isNumber v) (.as v Number)
(.canExecute v) (reify-ifn v)
(.hasArrayElements v) (into []
(for [i (range (.getArraySize v))]
(value->clj (.getArrayElement v i))))
(.hasMembers v) (into {}
(for [k (.getMemberKeys v)]
[k (value->clj (.getMember v k))]))
:else (throw (Exception. "Unsupported value"))))
(comment
(def js->clj (comp value->clj eval-js))
(js->clj "[{}]")
;=> [{}]
(js->clj "false")
;=> false
(js->clj "3 / 3.33")
;=> 0.9009009009009009
(js->clj "123123123123123123123123123123123")
;=> 1.2312312312312312E32
(def doubler (js->clj "(n) => {return n * 2;}"))
(doubler 2)
;=> 4
(js->clj "m = {foo: 1, bar: '2', baz: {0: false}};")
;=> {"foo" 1, "bar" "2", "baz" {"0" false}}
(def factorial
(eval-js "
var m = [];
function factorial (n) {
if (n == 0 || n == 1) return 1;
if (m[n] > 0) return m[n];
return m[n] = factorial(n - 1) * n;
}
x = {fn: factorial, memos: m};"))
((get (value->clj factorial) "fn") 12)
;=> 479001600
(get (value->clj factorial) "memos")
;=> [nil nil 2 6 24 120 720 5040 40320 362880 3628800 39916800 479001600]
((get (value->clj factorial) "fn") 24)
;=> 6.204484017332394E23
(get (value->clj factorial) "memos")
;=> [nil nil 2 6 24 120 720 5040 40320 362880 3628800 39916800 479001600 ... truncated for brevity]
(eval-js "var foo = 0xFFFF")
(eval-js "console.log(foo);")
;=> #object[org.graalvm.polyglot.Value 0x3f9d2028 "undefined"]
;65535
(js->clj "1 + '1'")
;=> "11"
(js->clj "['foo', 10, 2].sort()")
;=> [10 2 "foo"]
(def js-aset
(js->clj "(arr, idx, val) => { arr[idx] = val; return arr; }"))
(js-aset (ProxyArray/fromArray (object-array [1 2 3])) 1 nil)
;=> [1 nil 3]
(sort [{:b nil} \a 1 "a" "A" #{\a} :foo -1 0 {:a nil} "bar"])
(def js-sort
(js->clj "(...vs) => { return vs.sort(); }"))
(apply js-sort [{:b nil} \a 1 "a" "A" #{\a} :foo -1 0 {:a nil} "bar"])
;=> [-1 0 1 "A" #{\a} :foo {:a nil} {:b nil} "a" "a" "bar"]
(def variadic-fn
(js->clj "(x, y, ...z) => { return [x, y, z]; }"))
(apply variadic-fn :foo :bar (range 3))
;=> [:foo :bar [0 1 2]]
(def ->json
(js->clj "(x) => { return JSON.stringify(x); }"))
(->json [1 2 3])
;=> "[1,2,3]"
(->json (ProxyObject/fromMap {"foo" 1, "bar" nil}))
;=> "{\"foo\":1,\"bar\":null}"
(def json->
(js->clj "(x) => { return JSON.parse(x); }"))
(json-> (->json [1 2 3]))
;=> [1 2 3]
(json-> (->json (ProxyObject/fromMap {"foo" 1})))
;=> {"foo" 1}
(def json-object
(js->clj "(m) => { return m.foo + m.foo; }"))
(json-object (ProxyObject/fromMap {"foo" 1}))
;=> 2
(def clj-lambda
(js->clj "
m = {foo: [1, 2, 3],
bar: {
baz: ['a', 'z']
}};
(fn) => { return fn(m); }
"))
(clj-lambda
(proxy-fn #(clojure.walk/prewalk
(fn [v] (if (and (vector? v)
(not (map-entry? v)))
(vec (reverse v))
v))
%)))
;=> {"foo" [3 2 1], "bar" {"baz" ["z" "a"]}}
(def js-reduce
(let [reduce (js->clj "(f, coll) => { return coll.reduce(f); }")
reduce-init (js->clj "(f, coll, init) => { return coll.reduce(f, init); }")]
(fn
([f coll] (reduce f coll))
([f init coll] (reduce-init f coll init)))))
(js-reduce + (range 10))
;=> 45
(js-reduce + -5.5 (range 10))
;=> 39.5
(js-reduce (fn [acc elem]
(assoc acc (keyword (str elem)) (doubler elem)))
{}
(range 5))
;=> {:0 0, :1 2, :2 4, :3 6, :4 8}
(def log-coll
(js->clj "(coll) => { for (i in coll) console.log(coll[i]); }"))
(log-coll (repeatedly 3 #(do (prn 'sleeping)
(Thread/sleep 100)
(rand))))
(log-coll (range))
"nice")
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment