naga.lang.pabu — org.clojars.quoll/naga 0.2.22

Implements Pabu, which is a Prolog-like language for Naga. Parses code and returns Naga rules.

Args clj/s

ast->axiom clj/s

(ast->axiom {axiom :axiom :as axiom-ast})

Inputs: [{axiom :axiom, :as axiom-ast} :- AxiomAST] Returns: Axiom

Converts the axiom structure returned from the parser

ast->rule clj/s

(ast->rule {:keys [head body] :as rule-ast})

Inputs: [{:keys [head body], :as rule-ast} :- RuleAST] Returns: Rule

Converts the rule structure returned from the parser

AxiomAST clj/s

builtin-labels clj/s

builtins clj/s

ExpressionPredicate clj/s

filter->string clj/s

(filter->string [p])

Inputs: [[p] :- FilterPattern] Returns: s/Str

not-data-property? clj/s

(not-data-property? k)

Inputs: [k]

pattern->string clj/s

(pattern->string p)

Inputs: [p :- Pattern] Returns: s/Str

PatternPredicate clj/s

Predicate clj/s

predicate->string clj/s

(predicate->string epv)

Inputs: [epv :- EPVPattern] Returns: s/Str

property-namespaces clj/s

Set of namespaces that refer to data properties and never to functions

ps clj/s

(ps e)

read-str clj/s

(read-str s)

Inputs: [s :- s/Str] Returns: {:rules [Rule], :axioms [Axiom]}

Reads a string

read-stream clj

(read-stream in)

Inputs: [in :- InputStream] Returns: Program

Reads a input stream

rule->str clj/s≠

clj

(rule->str rule)

(rule->str {:keys [head body name] :as rule} include-name?)

cljs

(rule->str G__9007)

(rule->str G__9011 G__9012)

Inputs: ([rule :- Rule] [{:keys [head body name], :as rule} :- Rule include-name? :- s/Bool]) Returns: s/Str

Creates a textual representation for the rule

RuleAST clj/s

structure clj/s

(structure ast-data)

Converts the AST for a structure into either a seq of triplets or predicates. Types are intentionally loose, since it's either a pair or a list.

triplet clj/s

(triplet raw)

Inputs: [raw] Returns: Triple

Converts raw parsed predicate information into a single triple

triplets clj/s

(triplets [property [s o :as args]])

Inputs: [[property [s o :as args]]] Returns: [Triple]

Converts raw parsed predicate information into a seq of triples

VK clj/s

Either a Variable or a Keyword