naga.rules — org.clojars.quoll/naga 0.3.6

Defines rule structures and constructors to keep them consistent

bindings? clj/s

(bindings? b)

check-symbol clj/s

(check-symbol sym)

Asserts that symbols are unbound variables for a query. Return true if it passes.

collect-patterns clj/s

(collect-patterns body)

Inputs: [body :- Body] Returns: [EPVPattern]

Recurses through a rule body to find all EPV Patterns

compatible clj/s

(compatible x y)

create-program clj/s

(create-program rules axioms)

Inputs: [rules :- [Rule] axioms :- [Axiom]] Returns: Program

Converts a sequence of rules into a program. A program consists of a map of rule names to rules, where the rules have dependencies.

dbg clj/s

(dbg x)

epv-pattern? clj/s

(epv-pattern? pattern)

find-matches clj/s

(find-matches a [nm sb])

Inputs: [a :- EPVPattern [nm sb] :- [(s/one s/Str "rule-name") (s/one Body "body")]] Returns: [RulePatternPair]

returns a sequence of name/pattern pairs where a matches a pattern in a named rule

get-vars clj/s

(get-vars [f & r :as pattern])

mark-unbound clj/s

(mark-unbound head body)

Convert a head to use fresh vars for any vars that are unbound. Scans the vars in the body to identify which vars are unbound.

match? clj/s

(match? a b)

Inputs: [a :- EPVPattern b :- EPVPattern] Returns: s/Bool

Does pattern a match pattern b?

named-rule clj/s

(named-rule name {:keys [head body salience downstream]})

Inputs: [name :- Rule {:keys [head body salience downstream]} :- s/Str] Returns: Rule

Creates a rule the same as an existing rule, with a different name.

operators clj/s

r clj/s macro

(r & [f :as rs])

Create a rule, with an optional name. Var symbols need not be quoted.

regen-rewrite clj/s

(regen-rewrite head body)

Rewrites rules that are generating new entities to avoid them in future iterations. This requires the generated entities to be subtracted from the patterns in the rule body.

rule clj/s≠

clj

(rule head body)

(rule head body name)

cljs

(rule G__22480 G__22481)

(rule G__22485 G__22486 G__22487)

Inputs: ([head body] [head body name]) Returns: Rule

Creates a new rule

simple-vars clj/s

(simple-vars pattern)

specials clj/s

strip-special clj/s

(strip-special s)

var-for* clj/s

(var-for* fv)