std.lang.base.emit-common — xyz.zcaudate/std.lang 4.1.0

*compressed* clj

*emit-fn* clj

*emit-internal* clj

*explode* clj

*indent* clj

*max-len* clj

*multiline* clj

*trace* clj

+emit-lookup+ clj

emit-array clj

(emit-array array grammar mopts)

(emit-array array grammar mopts emit-fn)

returns an array of emitted strings

emit-assign clj

(emit-assign raw args grammar mopts)

emits a setter expression

emit-between clj

(emit-between raw args grammar mopts)

emits the raw symbol between two elems

emit-bi clj

(emit-bi raw args grammar mopts)

emits infix with two args

emit-class-static-invoke clj

(emit-class-static-invoke raw [sym field & args] grammar mopts)

creates

emit-comment clj

(emit-comment _ [tag & more :as form] grammar mopts)

emits a comment

emit-common clj

(emit-common form grammar mopts)

emits a string based on grammar

emit-common-loop clj

(emit-common-loop form grammar mopts)

(emit-common-loop form grammar mopts fn-lookup fn-default)

emits the raw string

emit-free clj

(emit-free {:keys [sep]} [tag & more :as form] grammar mopts)

emits string with multiline support

emit-free-raw clj

(emit-free-raw sep args grammar mopts)

emits free value

emit-indent clj

(emit-indent _ [tag & more :as form] grammar mopts)

emits an indented form

emit-index clj

(emit-index raw args grammar mopts)

creates an indexed expression

emit-index-entry clj

(emit-index-entry v grammar mopts)

classifies the index entry

emit-infix clj

(emit-infix raw args grammar mopts)

emits infix ops

emit-infix-default clj

(emit-infix-default raw args default grammar mopts)

emits infix with a default value

emit-infix-if clj

(emit-infix-if [_ & forms] grammar mopts)

emits an infix if string

emit-infix-if-single clj

(emit-infix-if-single [_ check then else] grammar mopts)

checks for infix in single

(emit-infix-if '(:? true x y) helper/+default+ {}) => "true ? x : y"

emit-infix-pre clj

(emit-infix-pre raw args grammar mopts)

emits infix with a default value

emit-internal clj

(emit-internal [_ value] grammar mopts)

emits string within the form

emit-internal-str clj

(emit-internal-str [_ value] grammar mopts)

emits internal string

emit-invoke clj

(emit-invoke _ [sym & args :as form] grammar mopts)

general invoke call, incorporating keywords

emit-invoke-args clj

(emit-invoke-args args grammar mopts)

produces the string for invoke call

emit-invoke-kw-pair clj

(emit-invoke-kw-pair [k v] grammar mopts)

emits a kw argument pair

emit-invoke-layout clj

(emit-invoke-layout str-array grammar mopts)

layout for invoke blocks

(emit-invoke-layout ["ab\nc" "de\nf"] helper/+default+ {}) => "(ab\nc,de\nf)"

emit-invoke-raw clj

(emit-invoke-raw raw args grammar mopts)

invoke call for reserved ops

emit-invoke-static clj

(emit-invoke-static [sym & args] grammar mopts)

generates a static call, alternat

emit-invoke-typecast clj

(emit-invoke-typecast form grammar mopts)

generates typecast expression

emit-macro clj

(emit-macro _ [tag & more :as form] grammar mopts)

emits form

emit-new clj

(emit-new raw [sym & more :as args] grammar mopts)

invokes a constructor

emit-op clj

(emit-op key
         [sym & args :as form]
         {:keys [reserved] :as grammar}
         mopts
         &
         [expansion])

helper for the emit op

emit-post clj

(emit-post raw args grammar mopts)

emits string after the arg

emit-postfix clj

(emit-postfix raw args grammar mopts)

emits operator before the arg

emit-pre clj

(emit-pre raw args grammar mopts)

emits string before the arg

emit-prefix clj

(emit-prefix raw args grammar mopts)

emits operator before the arg

emit-reserved-value clj

(emit-reserved-value form {:keys [reserved] :as grammar} mopts)

emits a reserved value

emit-return clj

(emit-return raw args grammar mopts)

creates a return type statement

emit-return-base clj

(emit-return-base raw args grammar mopts)

return base type

emit-return-do clj

(emit-return-do arg grammar mopts)

creates a return statement on do block

emit-squash clj

(emit-squash _ [tag & more] grammar mopts)

emits a squashed representation

emit-symbol clj

(emit-symbol sym grammar mopts)

emits symbol allowing for custom functions

emit-symbol-classify clj

(emit-symbol-classify sym {:keys [lang module entry book snapshot] :as mopts})

classify symbol given options

(emit-symbol-classify 't/hello {:module {:alias '{t table}}}) => '[:alias table]

(emit-symbol-classify 't.n/hello {:module {:alias '{t table}}}) => '[:unknown t.n]

emit-symbol-standard clj

(emit-symbol-standard sym grammar {:keys [lang layout module] :as mopts})

emits a standard symbol

(emit-symbol-standard 'print! helper/+default+ {:layout :full}) => "printf"

(emit-symbol-standard 'print! {:token {:symbol {:replace {}} :string {:quote :single}}} {:layout :full}) => "print!"

emit-token clj

(emit-token key token grammar mopts)

customisable emit function for tokens

emit-unit clj

(emit-unit {:keys [raw default transform] :as props} [_ value] grammar mopts)

emits a unit

emit-with-decorate clj

(emit-with-decorate _ [_ opts form] grammar mopts)

customisable emit function for global vars

emit-with-global clj

(emit-with-global _ [_ token] grammar mopts)

customisable emit function for global vars

emit-with-rand clj

(emit-with-rand _ [_ & [type]] grammar mopts)

injects uuid for testing

emit-with-uuid clj

(emit-with-uuid _ [_ & [seed0 seed1 :as seeds]] grammar mopts)

injects uuid for testing

emit-wrappable? clj

(emit-wrappable? form grammar)

checks if form if wrappable

emit-wrapping clj

(emit-wrapping form grammar mopts)

emits a potentially wrapped form

form-key clj

(form-key form {:keys [banned reserved] :as grammar})

returns the key associated with the form

invoke-kw-parse clj

(invoke-kw-parse args)

seperates standard and keyword arguments

newline-indent clj

(newline-indent)

returns a newline with indent

with-compressed clj macro

(with-compressed & body)

formats without newlines and indents

with-indent clj macro

(with-indent [& increment] & body)

adds indentation levels

with-trace clj macro

(with-trace & body)

form to control trace option

with:explode clj macro

(with:explode & body)

form to control explode option

wrapped-str clj

(wrapped-str inner path grammar)

wrapped string using :start and :end keys of grammar