(ns my.m$macros)
(require '[reagent.core :as r])
(require '[reagent.ratom :as ratom])
(map inc [1 2 3])(println "Hello ClojureX")
(+ 1 2 3)(set! (.-innerHTML js/klipse-container)
"<div style='color:blue;'>
Hello <strong>World</strong>!
</div>")
nil[:div {:style {:color "blue"}}
"Hello " [:strong "World"] "!"](ns my.m$macros)
(defmacro dbg [x]
`(let [x# ~x]
(println (str '~x " => " x#))
x#))(my.m/dbg (map inc [1 2 3]))
Definition: Bootstrapping is the process of writing a compiler in the same language that it intends to compile
Example: Eval written in LISP
Application: Once a language that transpiles to javascript is bootstrapped it can run on a web page
Fact: ClojureScript has been bootstrapped in July 2015
(ns my.sandbox)
(require '[cljs.js :as cljsjs])(def cljsjs-state (cljsjs/empty-state))(cljsjs/eval-str cljsjs-state
"(map inc [1 2 3])"
""
{:eval cljsjs/js-eval}
println)options details:
call construct. Defaults to false.(cljsjs/compile-str cljsjs-state
"(let [a 1]
(+ a 2))"
""
{ }
(comp println :value))options details:
call construct. Defaults to false.With :statement context (default)
(cljsjs/eval-str cljsjs-state
"(if 1 2 3)"
""
{:eval cljsjs/js-eval
:context :statement}
println)With :expr context (default)
(cljsjs/eval-str cljsjs-state
"(if 1 2 3)"
""
{:eval cljsjs/js-eval
:context :expr}
println)(defn eval [exp]
(cljsjs/eval-str cljsjs-state
exp
""
{:eval cljsjs/js-eval
:context :expr}
println))(require '[viebel.gist-983676a98aee0991cfb002a67676602f.raw.split-expressions :refer [split-expressions]])
(defn eval-several-expressions [code]
(loop [exps (split-expressions code)
res nil]
(if (seq exps)
(recur (rest exps) (eval (first exps)))
res)))(eval-several-expressions "(def a 4) (if a 1 2)")
The implementor needs to provide a custom mechanism for namespace resolution
(cljsjs/eval-str cljsjs-state
"(require 'my.ns)"
""
{:eval cljsjs/js-eval}
println)The load function is called with two arguments - a map and a callback function:
The map has the following keys:
:name - the name of the library (a symbol):macros - modifier signaling a macros namespace load:path - munged relative library path (a string)(cljsjs/eval-str cljsjs-state
"(require 'my.ns)"
""
{:eval cljsjs/js-eval
:load (fn [data callback] (println data))}
println)It is up to the implementor to correctly resolve the corresponding .cljs, .cljc, or .js resource (the order must be respected).
Upon resolution, the callback should be invoked with a map containing the following keys:
:lang - the language, :clj for clojurescript or :js for javascript:source - the source of the library (a string)If the resource could not be resolved, the callback should be invoked with nil.
(cljsjs/eval-str cljsjs-state
"(require '[my.bar :refer [foo]])
(+ foo 10)"
""
{:eval cljsjs/js-eval
:load (fn [data callback] (callback {:lang :clj
:source "(ns my.bar)
(def foo 12)"}))}
println)
All the details are in Github klipse/lang/clojure/io.cljs.
Super cool String manipulation library: superstring.
(require '[superstring.core :as superstring])
(superstring/swap-case "Hello ClojureX!")
Many popular clojure libs are available out-of-the box in Klipse:
(require '[clojure.math.combinatorics :refer [permutations]])
(permutations [1 2 3])| (ns viebel.gist-3800b8ebae5292921c7d6fcb6c995c1f.raw.body-color) | |
| (defn set-bg-color [c] | |
| (set! (.. js/document -body -style -backgroundColor) c)) | |
| (defn set-bg-color-element [e c] | |
| (set! (.. e -style -backgroundColor) c)) |
(require
'[goog.dom :as dom])
(require
'[viebel.gist-3800b8ebae5292921c7d6fcb6c995c1f.raw.body-color :refer [set-bg-color-element]])
(let [colors ["blue" "red" "yellow" "magenta" "cyan" "green" "purple" "coral" "dodgerblue" "pink"]]
(set-bg-color-element (dom/getElement "klipse-color-me") (rand-nth colors)))(map inc (range))
(defn foo [x] (if x 1 2))
(defn foo [x] (if x 1 2))
#_(loop []
(foo 9)
(recur))
Can you see the differences?
How do we get from the 1st code snippet to the second?
(defn hello [name]
[:span "Hello "
[:strong name]])
[hello "ClojureX"](defn hello [name]
[:span "Hello "
[:strong name]])
(reagent.core/render [hello "ClojureX"] js/klipse-container)reagent.core/render call
Thank you Timothy Pratley!
The eval function
(defn eval-code [exp]
(cljsjs/eval-str cljsjs-state
exp
""
{:eval cljsjs/js-eval}
println))The code as a string
(def code "(defn hello [name]
[:span \"Hello \"
[:strong name]])
[hello \"ClojureX\"]")Separate the component from the rest of the code
(def expressions (split-expressions code))
(def component (cljs.reader/read-string (last expressions)))Rewrite the code
(def rewritten-code (str (first expressions) "\n"
`(reagent.core/render ~component js/klipse-container)))
rewritten-codeEvaluate the rewritten code
(eval-code rewritten-code)
It’s super simple: it’s nothing more than adding a javacript tag!
Get inspired by the best blog posts out there:
As of November 2019, Klipse supports 13 languages: clojure, ruby, javascript, python, scheme, php, brainfuck, c++, lua, ocaml, reasonml, common lisp, prolog.
It takes less than 10 lines of code to add a new language. See the guide.
source special form
powered by Klipse 1 / 38