; Expressions' embedding: a plain tree as an expression document's tree,
; and back again. This is a library of definitions, each named
; `expr-...`, which a host links with its own program and with the render
; (alchemy's `compile_sources`). It has two entry points: `expr-embed`
; takes a plain tree's events to an expression tree's, and `expr-unembed`,
; its reverse, takes them back. Nothing else here is the host's to call.
;
; Both are the identity. The reader builds its trees on jsonic's values,
; so every plain tree is already an expression tree: a list whose first
; element is a default operator and whose count makes an operation is
; one, and the render writes it in infix, the operator being its source
; text (`+`, `-`, `*`, `/`, `%`, or `(` for a group) or an object that
; describes it, whose `src` member is that text, as the reader's own
; value carries it; every other value is a value of jsonic's, which the
; render writes as jsonic. A list that only looks like an operation
; reads back as the same tree either way, once each operator is reduced
; to its source text as the shared fixtures' simplifier, Go's `Simplify`
; and Rust's `simplify` reduce it, so nothing needs refusing. What the
; round trip changes is what the render's conventions change (the
; manifest's loss list): an operator's description is written as its
; source text, a negative number reads back as the operator `-` applied
; to its magnitude, and a number that is not finite as a string.
; The embedding: a plain tree's events in, the same events out.
def expr-embed [input]
input
; The reverse: an expression tree's events in, the same events out.
def expr-unembed [input]
input