Formulas / dynamic blocks / extensions

[alexandergunnarson]

In addition to the option of putting plain/formatted text in a block, I'd like to be able to have a block be dynamic, i.e. create dynamic values à la Coda formulas. A dynamic block might be created with /dyn, and it would allow reference to the last Clojure expression in its body which it would interpret with Sci. It might look something like:

Example 1

{{dynamic
(def the-thing-to-add 123)

(defn add-123 [x] (+ x the-thing-to-add))
}}

Example 2

;; Assume this is block ID a3df74
{{dynamic
;; This does nothing and is not referenceable
(str "bcd" "xyz") 

;; This refers to page attributes
;; Doesn't need to be `def`'ed; it is referenceable by its
;; block ID (see Example 3)
(str (:title *page*) (add-123 20.4) the-thing-to-add)
}}

Example 3

{{dynamic
;; Refers to value in Example 2
(str "abc" @(athens/value "a3df74"))
}}

Example 4

{{dynamic
;; Gets rendered as Hiccup
;; Should be able to, à la Example 2, refer to arbitrary
;; values and components
(athens/component
  [:div "Hello world!"])
}}

Example 5

{{dynamic
;; Gets rendered inline
(athens/js-link "https://my-site.com/cool-thing.js")
}}

Applicability to other features

See also #2003 for how this might work in titles, and #845 for how this might play nicely with queries.

Applicability to "Athens as ubereditor"

In fact, this provides a way for defining arbitrary amounts of code within Athens — even whole libraries and apps, if we provide namespacing support — which opens up a whole new way of editing code and combining it with the broader world. Because Athens subsumes them, you don't need:

• A separate editor, provided Athens provides a rich code editing experience
• Notebooks like Clerk, since the Athens way of coding would be essentially literate programming++
• Documentation generators like Codox
• Markdown files separated from the code

Plus the code is versionable (using DataScript history or equivalent), directly referable, and accessible via deep link. Granted, it's an open question how such an approach would play nicely with git, and how non-ClojureScript code would work, but in theory these problems are surmountable (e.g. as to the git problem, just output the code blocks to files based on their namespace).