Struct Program 

pub struct Program {

    pub imports: Vec<UseDecl>,
    pub functions: Vec<FuncDef>,
    pub domains: Vec<DomainDecl>,
    pub predicates: Vec<PredDecl>,
    pub rules: Vec<Rule>,
    pub constraints: Vec<Constraint>,
    pub queries: Vec<Query>,
    pub prob_facts: Vec<ProbFact>,
    pub annotated_disjunctions: Vec<AnnotatedDisjunction>,
    pub evidence: Vec<Evidence>,
    pub prob_queries: Vec<ProbQuery>,
    pub neural_predicates: Vec<NeuralPredDecl>,
    pub learnable_rules: Vec<LearnableRule>,
    pub directives: Directives,
}

A complete XLOG program

Fields

imports: Vec<UseDecl>

Import declarations (use ...).

functions: Vec<FuncDef>

User-defined function definitions.

domains: Vec<DomainDecl>

Domain declarations.

predicates: Vec<PredDecl>

Predicate type declarations.

rules: Vec<Rule>

Rules and facts.

constraints: Vec<Constraint>

Integrity constraints (:- ...).

queries: Vec<Query>

Queries (?- ...).

prob_facts: Vec<ProbFact>

Probabilistic facts (p::atom.).

annotated_disjunctions: Vec<AnnotatedDisjunction>

Annotated disjunctions.

evidence: Vec<Evidence>

Evidence statements.

prob_queries: Vec<ProbQuery>

Probabilistic queries (query(atom).).

neural_predicates: Vec<NeuralPredDecl>

Neural predicate declarations.

learnable_rules: Vec<LearnableRule>

Learnable rule templates (ILP).

directives: Directives

Compilation directives.

Implementations

impl Program

pub fn new() -> Self

Create an empty program.

pub fn facts(&self) -> impl Iterator<Item = &Rule>

Iterate over ground facts (rules with empty bodies).

pub fn proper_rules(&self) -> impl Iterator<Item = &Rule>

Iterate over proper rules (non-fact rules with bodies).

pub fn defined_predicates(&self) -> Vec<&str>

Collect the set of predicate names defined (appearing as rule heads).

pub fn is_probabilistic_profile(&self) -> bool

Returns true if this program uses probabilistic features.

pub fn prob_engine(&self) -> ProbEngine

Return the probabilistic engine (from directives, or the default).

pub fn merge_from( &mut self, other: &Program, imported_items: Option<&HashSet<String>>, )

Merge another program’s exports into this program. Used for importing modules - adds predicates, functions, rules from the imported module. Only merges public items (private items are not exported).

Arguments

• other - The program to merge from
• imported_items - Optional set of specific items to import. If None, imports all public items.

Trait Implementations

impl Clone for Program

fn clone(&self) -> Program

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Program

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Program

fn default() -> Program

Returns the “default value” for a type.