v0.1.5

Cargo.toml

@@ -15,21 +15,21 @@ categories = [
 description = "This crate focuses on building concrete implementations for Turing Machines."
 edition = "2024"
 homepage = "https://github.com/FL03/rstm/wiki"
-keywords = ["turing machine", "tm", "fsm", "computation"]
+keywords = ["turing-machine", "tm", "fsm", "computation"]
 license = "Apache-2.0"
 readme = "README.md"
 repository = "https://github.com/FL03/rstm.git"
 rust-version = "1.91.0"
-version = "0.1.4"
+version = "0.1.5"
 
 [workspace.dependencies]
 # local
-rstm = { default-features = false, path = "crates/rstm", version = "0.1.4" }
-rstm-core = { default-features = false, path = "crates/core", version = "0.1.4" }
-rstm-macros = { default-features = false, path = "crates/macros", version = "0.1.4" }
-rstm-state = { default-features = false, path = "crates/state", version = "0.1.4" }
-rstm-tape = { default-features = false, path = "crates/tape", version = "0.1.4" }
-rstm-traits = { default-features = false, path = "crates/traits", version = "0.1.4" }
+rstm = { default-features = false, path = "crates/rstm", version = "0.1.5" }
+rstm-core = { default-features = false, path = "crates/core", version = "0.1.5" }
+rstm-macros = { default-features = false, path = "crates/macros", version = "0.1.5" }
+rstm-state = { default-features = false, path = "crates/state", version = "0.1.5" }
+rstm-tape = { default-features = false, path = "crates/tape", version = "0.1.5" }
+rstm-traits = { default-features = false, path = "crates/traits", version = "0.1.5" }
 # custom
 contained = { default-features = false, features = ["macros"], version = "0.2.3" }
 rspace-traits = { default-features = false, version = "0.0.9" }

crates/core/src/programs/impls/imp_program_base.rs

@@ -107,12 +107,24 @@ where
     {
         self.rules().get(head)
     }
-
+    /// given a state and symbol, returns the corresponding tail if it exists within the 
+    /// ruleset
     pub fn find_tail(&self, state: State<&Q>, sym: &A) -> Option<&Tail<Q, A>>
     where
         R: Ruleset<Q, A>,
         R::Rule: Instruction<Q, A, Head = Head<Q, A>, Tail = Tail<Q, A>>,
     {
         self.rules().find_tail(state, sym)
     }
+    /// returns the number of rules within the ruleset
+    pub fn len(&self) -> usize
+    {
+        self.rules().len()
+    }
+    /// returns true if the ruleset is considered empty (i.e. contains no rules), 
+    /// otherwise false.
+    pub fn is_empty(&self) -> bool
+    {
+        self.rules().is_empty()
+    }
 }

crates/core/src/programs/traits/ruleset.rs

@@ -15,16 +15,27 @@ where
     type Rule: Instruction<Q, A>;
 
     private! {}
+
+    fn len(&self) -> usize;
+
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
 }
 
 pub trait Ruleset<Q, A>: RawRuleset<Q, A>
 where
     Q: RawState,
     Self::Rule: Instruction<Q, A, Head = Head<Q, A>, Tail = Tail<Q, A>>,
 {
-    fn get(&self, head: &Head<Q, A>) -> Option<&Tail<Q, A>>;
 
     fn find_tail(&self, state: State<&Q>, sym: &A) -> Option<&Tail<Q, A>>;
+
+    fn get(&self, head: &Head<Q, A>) -> Option<&Tail<Q, A>>;
+
+    fn find_head(&self, Head { state, symbol }: Head<&Q, &A>) -> Option<&Tail<Q, A>> {
+        self.find_tail(state, symbol)
+    }
 }
 
 pub trait RuleSetMut<Q, A>: RawRuleset<Q, A>
@@ -47,6 +58,10 @@ where
     type Rule = R::Rule;
 
     seal! {}
+
+    fn len(&self) -> usize {
+        (*self).len()
+    }
 }
 
 macro_rules! get_tail {
@@ -81,6 +96,14 @@ where
     type Rule = I;
 
     seal! {}
+
+    fn len(&self) -> usize {
+        <[I]>::len(self)
+    }
+
+    fn is_empty(&self) -> bool {
+        <[I]>::is_empty(self)
+    }
 }
 
 impl<I, Q, A> Ruleset<Q, A> for [I]
@@ -105,6 +128,14 @@ where
     type Rule = I;
 
     seal! {}
+
+    fn len(&self) -> usize {
+        <[I]>::len(self)
+    }
+
+    fn is_empty(&self) -> bool {
+        <[I]>::is_empty(self)
+    }
 }
 
 impl<I, Q, A> Ruleset<Q, A> for &[I]
@@ -130,6 +161,14 @@ where
     type Rule = I;
 
     seal! {}
+
+    fn len(&self) -> usize {
+        <[I]>::len(self)
+    }
+
+    fn is_empty(&self) -> bool {
+        <[I]>::is_empty(self)
+    }
 }
 
 impl<I, Q, A> Ruleset<Q, A> for &mut [I]
@@ -172,6 +211,14 @@ where
     type Rule = I;
 
     seal! {}
+
+    fn len(&self) -> usize {
+        <[I]>::len(self)
+    }
+
+    fn is_empty(&self) -> bool {
+        <[I]>::is_empty(self)
+    }
 }
 
 impl<const N: usize, I, Q, A> Ruleset<Q, A> for [I; N]
@@ -205,6 +252,14 @@ mod impl_alloc {
         type Rule = I;
 
         seal! {}
+
+        fn len(&self) -> usize {
+            <Vec<I>>::len(self)
+        }
+
+        fn is_empty(&self) -> bool {
+            <Vec<I>>::is_empty(self)
+        }
     }
 
     impl<I, Q, A> Ruleset<Q, A> for Vec<I>
@@ -228,7 +283,16 @@ mod impl_alloc {
         I: Instruction<Q, A>,
     {
         type Rule = I;
+
         seal! {}
+
+        fn len(&self) -> usize {
+            <BTreeSet<I>>::len(self)
+        }
+
+        fn is_empty(&self) -> bool {
+            <BTreeSet<I>>::is_empty(self)
+        }
     }
 
     impl<I, Q, A> Ruleset<Q, A> for BTreeSet<I>
@@ -254,7 +318,16 @@ mod impl_alloc {
         type Rule = Rule<Q, A>;
 
         seal! {}
+
+        fn len(&self) -> usize {
+            <BTreeMap<Head<Q, A>, Tail<Q, A>>>::len(self)
+        }
+
+        fn is_empty(&self) -> bool {
+            <BTreeMap<Head<Q, A>, Tail<Q, A>>>::is_empty(self)
+        }
     }
+
     impl<Q, A> Ruleset<Q, A> for BTreeMap<Head<Q, A>, Tail<Q, A>>
     where
         Q: RawState + Ord,
@@ -282,14 +355,23 @@ mod impl_hashbrown {
     use core::hash::Hash;
     use hashbrown::{HashMap, HashSet};
 
-    impl<Q, A> RawRuleset<Q, A> for HashSet<Rule<Q, A>>
+    impl<I, Q, A> RawRuleset<Q, A> for HashSet<I>
     where
+        I: Instruction<Q, A>,
         Q: RawState + Eq + Hash,
         A: Eq + Hash,
     {
         type Rule = Rule<Q, A>;
 
         seal! {}
+
+        fn len(&self) -> usize {
+            <HashSet<I>>::len(self)
+        }
+
+        fn is_empty(&self) -> bool {
+            <HashSet<I>>::is_empty(self)
+        }
     }
 
     impl<Q, A> Ruleset<Q, A> for HashSet<Rule<Q, A>>
@@ -314,6 +396,14 @@ mod impl_hashbrown {
         type Rule = Rule<Q, A>;
 
         seal! {}
+
+        fn len(&self) -> usize {
+            <HashMap<Head<Q, A>, Tail<Q, A>>>::len(self)
+        }
+
+        fn is_empty(&self) -> bool {
+            <HashMap<Head<Q, A>, Tail<Q, A>>>::is_empty(self)
+        }
     }
 
     impl<Q, A> Ruleset<Q, A> for HashMap<Head<Q, A>, Tail<Q, A>>
@@ -343,14 +433,23 @@ mod impl_std {
     use core::hash::Hash;
     use std::collections::{HashMap, HashSet};
 
-    impl<Q, A> RawRuleset<Q, A> for HashSet<Rule<Q, A>>
+    impl<I, Q, A> RawRuleset<Q, A> for HashSet<I>
     where
+        I: Instruction<Q, A>,
         Q: RawState + Eq + Hash,
         A: Eq + Hash,
     {
         type Rule = Rule<Q, A>;
 
         seal! {}
+
+        fn len(&self) -> usize {
+            <HashSet<I>>::len(self)
+        }
+
+        fn is_empty(&self) -> bool {
+            <HashSet<I>>::is_empty(self)
+        }
     }
 
     impl<Q, A> Ruleset<Q, A> for HashSet<Rule<Q, A>>
@@ -375,6 +474,14 @@ mod impl_std {
         type Rule = Rule<Q, A>;
 
         seal! {}
+
+        fn len(&self) -> usize {
+            <HashMap<Head<Q, A>, Tail<Q, A>>>::len(self)
+        }
+
+        fn is_empty(&self) -> bool {
+            <HashMap<Head<Q, A>, Tail<Q, A>>>::is_empty(self)
+        }
     }
 
     impl<Q, A> Ruleset<Q, A> for HashMap<Head<Q, A>, Tail<Q, A>>

default.nix

@@ -27,7 +27,7 @@ let
   };
 
   common = {
-    version = "0.1.4";
+    version = "0.1.5";
     src = self;
 
     cargoLock = {

flake.nix

@@ -20,7 +20,7 @@
       in rec {
         packages.default = pkgs.rustPlatform.buildRustPackage {
           pname = "rstm";
-          version = "0.1.4";
+          version = "0.1.5";
           src = self; # ./.;
           cargoLock = { lockFile = ./Cargo.lock; };
         };