CrossClj

0.6.9 docs

SourceDocs



RECENT
    VARS
    -analyze-form
    -parse
    analyze
    analyze-body
    analyze-const
    analyze-fn-method
    analyze-form
    analyze-in-env
    analyze-let
    analyze-map
    analyze-seq
    analyze-set
    analyze-symbol
    analyze-vector
    create-var
    empty-env
    macroexpand
    macroexpand-1
    parse
    parse-catch
    parse-def
    parse-do
    parse-dot
    parse-fn*
    parse-if
    parse-invoke
    parse-let*
    parse-letfn*
    parse-loop*
    parse-new
    parse-quote
    parse-recur
    parse-set!
    parse-throw
    parse-try
    parse-var
    specials
    split-with'
    valid-binding-symbol?
    validate-bindings
    var?
    wrapping-meta

    « Index of all namespaces of this project

    Analyzer for clojure code, host agnostic.
    
    Entry point:
    * analyze
    
    Platform implementers must provide dynamic bindings for:
    * macroexpand-1
    * parse
    * create-var
    * var?
    
    Setting up the global env is also required, see clojure.tools.analyzer.env
    
    See clojure.tools.analyzer.core-test for an example on how to setup the analyzer.
    (-parse form env)
    Takes a form and an env map and dispatches on the head of the form, that is
    a special form.
    (analyze form env)
    Given a form to analyze and an environment, a map containing:
    * :locals     a map from binding symbol to AST of the binding value
    * :context    a keyword describing the form's context from the :ctx/* hierarchy.
     ** :ctx/expr      the form is an expression: its value is used
     ** :ctx/return    the form is an expression in return position, derives :ctx/expr
     ** :ctx/statement the value of the form is not used
    * :ns         a symbol representing the current namespace of the form to be
                  analyzed
    
    returns an AST for that form.
    
    Every node in the AST is a map that is *guaranteed* to have the following keys:
    * :op   a keyword describing the AST node
    * :form the form represented by the AST node
    * :env  the environment map of the AST node
    
    Additionaly if the AST node contains sub-nodes, it is guaranteed to have:
    * :children a vector of the keys of the AST node mapping to the sub-nodes,
                ordered, when that makes sense
    
    It is considered a node either the top-level node (marked with :top-level true)
    or a node that can be reached via :children; if a node contains a node-like
    map that is not reachable by :children, there's no guarantee that such a map
    will contain the guaranteed keys.
    (analyze-body body env)
    (analyze-const form env & [type])
    (analyze-fn-method [params & body :as form] {:keys [locals local], :as env})
    multimethodDynamic
    Like analyze, but does not mark the form with :top-level true
    
    (analyze-in-env env)
    Takes an env map and returns a function that analyzes a form in that env
    
    (analyze-let [op bindings & body :as form] {:keys [context loop-id], :as env})
    (analyze-map form env)
    (analyze-seq form env)
    (analyze-set form env)
    (analyze-symbol sym env)
    (analyze-vector form env)
    Dynamic
    (create-var sym env)
    Creates a var for sym and returns it
    
    (empty-env)
    Returns an empty env
    
    (macroexpand form env)
    Repeatedly calls macroexpand-1 on form until it no longer
    represents a macro form, then returns it.
    Dynamic
    (macroexpand-1 form env)
    If form represents a macro form, returns its expansion,
    else returns form.
    Dynamic
    (parse [op & args] env)
    Multimethod that dispatches on op, should default to -parse
    
    (parse-catch [_ etype ename & body :as form] env)
    (parse-def [_ sym & expr :as form] {:keys [ns], :as env})
    (parse-do [_ & exprs :as form] env)
    (parse-dot [_ target & [m-or-f & args] :as form] env)
    (parse-fn* [op & args :as form] env)
    (parse-if [_ test then else :as form] env)
    (parse-invoke [f & args :as form] env)
    (parse-let* form env)
    (parse-letfn* [_ bindings & body :as form] env)
    (parse-loop* form env)
    (parse-new [_ class & args :as form] env)
    (parse-quote [_ expr :as form] env)
    (parse-recur [_ & exprs :as form] {:keys [context loop-locals loop-id], :as env})
    (parse-set! [_ target val :as form] env)
    (parse-throw [_ throw :as form] env)
    (parse-try [_ & body :as form] env)
    (parse-var [_ var :as form] env)
    Set of special forms common to every clojure variant
    
    Private
    (split-with' pred coll)
    (valid-binding-symbol? s)
    (validate-bindings [op bindings & _ :as form] env)
    Dynamic
    (var? obj)
    Returns true if obj represent a var form as returned by create-var
    
    (wrapping-meta {:keys [form env], :as expr})