rstm-rules 0.0.9

this crate implements the core modules of the rstm sdk
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

/*
    Appellation: rstm-rules <library>
    Created At: 2025.08.30:18:45:29
    Contrib: @FL03
*/
//! Rules for the rstm framework

#![allow(
    clippy::module_inception,
    clippy::new_ret_no_self,
    clippy::needless_doctest_main,
    clippy::should_implement_trait
)]
#![cfg_attr(not(feature = "std"), no_std)]
#![cfg_attr(feature = "nightly", feature(allocator_api))]

#[cfg(feature = "alloc")]
extern crate alloc;

extern crate rstm_core as rstm;

#[macro_use]
mod macros {
    #[macro_use]
    pub(crate) mod seal;
}

#[doc(inline)]
pub use self::{
    error::*,
    rule::{LearnedRule, Rule},
    traits::*,
    types::*,
};

#[cfg(feature = "alloc")]
#[doc(inline)]
pub use self::program::*;
#[cfg(feature = "std")]
#[doc(inline)]
pub use self::rule_map::RuleMap;

pub mod error;
pub(crate) mod rule;

#[cfg(feature = "alloc")]
pub mod program;
#[cfg(feature = "std")]
pub mod rule_map;

pub mod traits {
    //! the traits defining compatible rules within the framework
    #[doc(inline)]
    pub use self::prelude::*;

    mod instruction;
    mod rulespace;

    mod prelude {
        #[doc(inline)]
        pub use super::instruction::*;
        #[doc(inline)]
        pub use super::rulespace::*;
    }
}

mod types {
    //! types essential to the construction of rules, programs, and other related objects
    #[doc(inline)]
    pub use self::prelude::*;

    mod prelude {
        #[doc(inline)]
        pub use super::aliases::*;
    }

    mod aliases {
        #[cfg(feature = "std")]
        use rstm_core::{Head, Tail};

        #[cfg(feature = "alloc")]
        pub(crate) type RuleVec<Q, S> = alloc::vec::Vec<crate::Rule<Q, S>>;

        /// A type alias for a [`HashMap`](std::collections::HashMap) with keys of type [`Head<Q, S>`] and values of type
        /// [`Tail<Q, S>`].
        #[cfg(feature = "std")]
        pub type HeadMap<Q = usize, S = usize> = std::collections::HashMap<Head<Q, S>, Tail<Q, S>>;
    }
}

#[doc(hidden)]
pub mod prelude {
    #[doc(no_inline)]
    pub use crate::rule::Rule;
    #[doc(no_inline)]
    pub use crate::traits::*;
    #[doc(no_inline)]
    pub use crate::types::*;

    #[doc(no_inline)]
    #[cfg(feature = "alloc")]
    pub use crate::program::Program;
    #[doc(no_inline)]
    #[cfg(feature = "std")]
    pub use crate::rule_map::RuleMap;
}