Struct IrProgram 

pub struct IrProgram {
    pub clauses: Vec<IrClause>,
    pub queries: Vec<IrQuery>,
    pub tabled_predicates: HashSet<(String, usize)>,
    pub diff_neural_predicates: HashSet<(String, usize, String)>,
    pub neural_gen_predicates: HashSet<(String, usize)>,
    pub neural_models: HashMap<String, String>,
    pub actions: Vec<IrAction>,
    pub neural_unify_threshold: f64,
    pub type_hierarchy: Vec<(Vec<String>, Option<String>)>,
}

A complete IR program: a collection of clauses, queries, and planning actions.

Fields

clauses: Vec<IrClause>

All clauses (facts and rules) in the program.

queries: Vec<IrQuery>

All queries in the program.

tabled_predicates: HashSet<(String, usize)>

Predicates declared with :- table functor/arity.

diff_neural_predicates: HashSet<(String, usize, String)>

Predicates declared with :- differentiable neural functor/arity using "model".

neural_gen_predicates: HashSet<(String, usize)>

Generative neural predicates declared with :- neural_gen functor/arity.

neural_models: HashMap<String, String>

Mapping from neural predicate (name/arity) to a named model (from :- neural_model).

actions: Vec<IrAction>

STRIPS-style planning actions registered in this program.

neural_unify_threshold: f64

Cosine-similarity threshold used by the ~= (neural unification) operator.

Set via :- neural_unify threshold(<value>).; defaults to 0.85.

type_hierarchy: Vec<(Vec<String>, Option<String>)>

PDDL type hierarchy: each entry is (child_types, parent).

Preserves the full type hierarchy from a PDDL domain so that round-tripping through IR does not flatten the type tree. For example, city location - object and truck car - vehicle become [ (["city", "location"], Some("object")), (["truck", "car"], Some("vehicle")) ].

Union (either) types in parameter annotations are stored with |-separated names (e.g. "brick|window").

Implementations

impl IrProgram

pub fn new() -> Self

Create an empty IrProgram.

impl IrProgram

pub fn validate_actions(&self) -> Result<(), (usize, ActionValidationError)>

Validate all actions in the program, returning the index of the first invalid action together with its ActionValidationError, or Ok(()) if all actions are well-formed.

This is a convenience wrapper around IrAction::validate that makes it easy to gate the planning pipeline on structural correctness.

Example

use gollum_ir::{IrAction, IrProgram, IrTerm};

let mut prog = IrProgram::new();
prog.actions.push(IrAction {
    name: "move".into(),
    parameters: vec!["X".into(), "Y".into()],
    preconditions: vec![
        IrTerm::Structure { name: "at".into(), args: vec![IrTerm::Var("X".into())] },
    ],
    effects: vec![
        IrTerm::Structure { name: "at".into(), args: vec![IrTerm::Var("Y".into())] },
    ],
    metadata: None,
});
assert!(prog.validate_actions().is_ok());

Trait Implementations

impl Clone for IrProgram

fn clone(&self) -> IrProgram

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IrProgram

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

Formats the value using the given formatter.

impl Default for IrProgram

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for IrProgram

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for IrProgram

fn eq(&self, other: &IrProgram) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for IrProgram

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for IrProgram