clara.rules.compiler — com.cerner/clara-rules 0.18.0

This namespace is for internal use and may move in the future. This is the Clara rules compiler, translating raw data structures into compiled versions and functions. Most users should use only the clara.rules namespace.

*compile-ctx* clj

add-production-load-order clj

(add-production-load-order productions)

Adds ::rule-load-order to metadata of productions. Custom DSL's may need to use this if creating a session in Clojure without calling mk-session below.

analyze-condition clj

(analyze-condition condition)

Inputs: [condition :- schema/Condition] Returns: {:bound #{sc/Symbol}, :unbound #{sc/Symbol}, :condition schema/Condition, :is-accumulator sc/Bool}

BetaNode clj

These nodes exist in the beta network.

build-network clj

(build-network id-to-node
               beta-roots
               alpha-fns
               productions
               fact-type-fn
               ancestors-fn
               activation-group-sort-fn
               activation-group-fn)

Inputs: [id-to-node :- #:sc{Int sc/Any} beta-roots alpha-fns productions fact-type-fn ancestors-fn activation-group-sort-fn activation-group-fn]

Constructs the network from compiled beta tree and condition functions.

clear-session-cache! clj

(clear-session-cache!)

Clears the cache of reusable Clara sessions, so any subsequent sessions will be re-compiled from the rule definitions. This is intended for use by tooling or specialized needs; most users can simply specify the :cache false option when creating sessions.

cljs-ns clj

(cljs-ns)

Returns the ClojureScript namespace being compiled during Clojurescript compilation.

compile-accum clj

(compile-accum accum env)

Used to create accumulators that take the environment into account.

compile-action clj

(compile-action binding-keys rhs env)

Compile the right-hand-side action of a rule, returning a function to execute it.

compile-alpha-nodes clj

(compile-alpha-nodes alpha-nodes)

Inputs: [alpha-nodes :- [schema/AlphaNode]] Returns: [{:type sc/Any, :alpha-fn sc/Any, (sc/optional-key :env) #:sc{Keyword sc/Any}, :children [sc/Num]}]

compile-condition clj

(compile-condition type destructured-fact constraints result-binding env)

Returns a function definition that can be used in alpha nodes to test the condition.

compile-join-filter clj

(compile-join-filter {:keys [type constraints args] :as unification-condition}
                     ancestor-bindings
                     element-bindings
                     env)

Compiles to a predicate function that ensures the given items can be unified. Returns a ready-to-eval function that accepts the following:

• a token from the parent node
• the fact
• a map of bindings from the fact, which was typically computed on the alpha side
• an environment

The function created here returns truthy if the given fact satisfies the criteria.

compile-test clj

(compile-test tests)

compiling-cljs? clj

(compiling-cljs?)

Return true if we are currently generating cljs code. Useful because cljx does not provide a hook for conditional macro expansion.

condition-to-node clj

(condition-to-node condition env parent-bindings)

Inputs: [condition :- schema/Condition env :- (sc/maybe #:sc{Keyword sc/Any}) parent-bindings :- #{sc/Keyword}] Returns: schema/ConditionNode

Converts a condition to a node structure.

condition-type clj

(condition-type condition)

Returns the type of a single condition that has been transformed to disjunctive normal form. The types are: :negation, :accumulator, :test, :exists, and :join

effective-type clj

(effective-type type)

field-name->accessors-used clj

(field-name->accessors-used type constraints)

Returns a map of field name to accessors for any field names of type used in the constraints.

flatten-expression clj

(flatten-expression expression)

Flattens expression as clojure.core/flatten does, except will flatten anything that is a collection rather than specifically sequential.

get-fields clj

(get-fields type)

Returns a map of field name to a symbol representing the function used to access it.

get-namespace-info clj

(get-namespace-info namespace)

Get metadata about the given namespace.

IRuleSource clj protocol

load-rules clj

(load-rules source)

mk-session clj

(mk-session sources-and-options)

Creates a new session using the given rule source. The resulting session is immutable, and can be used with insert, retract, fire-rules, and query functions.

mk-session* clj

(mk-session* productions options)

Inputs: [productions :- #{schema/Production} options :- #:sc{Keyword sc/Any}]

Compile the rules into a rete network and return the given session.

production-load-order-comp clj

(production-load-order-comp a b)

resolve-cljs-sym clj

(resolve-cljs-sym ns-sym sym)

Resolves a ClojureScript symbol in the given namespace.

sort-conditions clj

(sort-conditions conditions)

Inputs: [conditions :- [schema/Condition]] Returns: [schema/Condition]

Performs a topologic sort of conditions to ensure variables needed by child conditions are bound.

strict-map->Rulebase clj

(strict-map->Rulebase m6713 & [drop-extra-keys?__1339__auto__])

Factory function for class Rulebase, taking a map of keywords to field values. All keys are required, and no extra keys are allowed. Even faster than map->

to-alpha-graph clj

(to-alpha-graph beta-graph)

Inputs: [beta-graph :- schema/BetaGraph] Returns: [schema/AlphaNode]

Returns a sequence of [condition-fn, [node-ids]] tuples to represent the alpha side of the network.

to-beta-graph clj

(to-beta-graph productions)

Inputs: [productions :- #{schema/Production}] Returns: schema/BetaGraph

Produces a description of the beta network.

to-dnf clj

(to-dnf expression)

Convert a lhs expression to disjunctive normal form.

try-eval clj

(try-eval expr)

Evals the given expr. If an exception is thrown, it is caught and an ex-info exception is thrown with more details added. Uses compile-ctx for additional contextual info to add to the exception details.

validate-names-unique clj

(validate-names-unique productions)

Checks that all productions included in the session have unique names, throwing an exception if duplicates are found.

variables-as-keywords clj

(variables-as-keywords expression)

Returns a set of the symbols in the given s-expression that start with '?' as keywords