PTV/radn-rs
1
1
Fork 0
Code Issues 3 Pull Requests Packages Projects Releases Wiki Activity

reduce Rc usage with traversible

Browse Source
This commit is contained in:
AF 2023-06-16 06:08:31 +00:00
parent a1db73920b
commit 5dbd034b86
4 changed files with 29 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/flow/traversible.rs
View File

@ -11,7 +11,7 @@ use crate::func::*;
pub type Split<'a, T, A, D> = ( pub type Split<'a, T, A, D> = (
Rc<dyn TraversibleBinaryTree<'a, T, A, D>>, Rc<dyn TraversibleBinaryTree<'a, T, A, D>>,
Rc<dyn TraversibleBinaryTree<'a, T, A, D>>, Rc<dyn TraversibleBinaryTree<'a, T, A, D>>,
Rc<A>, A,
); );
pub trait TraversibleBinaryNode<'a, T: Monad<'a>, A: 'a, D: 'a + PartialEq>: 'a { pub trait TraversibleBinaryNode<'a, T: Monad<'a>, A: 'a, D: 'a + PartialEq>: 'a {

14
src/flow/traversible/algorithms/contains.rs
View File

@ -1,30 +1,30 @@
use crate::flow::traversible::*; use crate::flow::traversible::*;
pub fn n_contains<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>( pub fn n_contains<'a, T: MonadFail<'a, ()>, A: 'a + Clone, D: 'a + PartialEq>(
comparator: &'a dyn Comparator<A>, comparator: &'a dyn Comparator<A>,
n_set: Rc<dyn TraversibleBinaryNode<'a, T, A, D>>, n_set: Rc<dyn TraversibleBinaryNode<'a, T, A, D>>,
key: Rc<A>, key: A,
) -> T::F<()> { ) -> T::F<()> {
let (t_setl, t_setr, k_set) = n_set.split(); let (t_setl, t_setr, k_set) = n_set.split();
match comparator.pick_smaller(key.as_ref(), k_set.as_ref()) { match comparator.pick_smaller(&key, &k_set) {
Comparison::L => t_contains(comparator, t_setl, key), Comparison::L => t_contains(comparator, t_setl, key),
Comparison::E => T::pure(()), Comparison::E => T::pure(()),
Comparison::R => t_contains(comparator, t_setr, key), Comparison::R => t_contains(comparator, t_setr, key),
} }
} }
pub fn r_contains<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>( pub fn r_contains<'a, T: MonadFail<'a, ()>, A: 'a + Clone, D: 'a + PartialEq>(
comparator: &'a dyn Comparator<A>, comparator: &'a dyn Comparator<A>,
r_set: Rc<dyn TraversibleBinaryReference<'a, T, A, D>>, r_set: Rc<dyn TraversibleBinaryReference<'a, T, A, D>>,
key: Rc<A>, key: A,
) -> T::F<()> { ) -> T::F<()> {
T::bind(r_set.resolve(), |n_set| n_contains(comparator, n_set, key)) T::bind(r_set.resolve(), |n_set| n_contains(comparator, n_set, key))
} }
pub fn t_contains<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>( pub fn t_contains<'a, T: MonadFail<'a, ()>, A: 'a + Clone, D: 'a + PartialEq>(
comparator: &'a dyn Comparator<A>, comparator: &'a dyn Comparator<A>,
t_set: Rc<dyn TraversibleBinaryTree<'a, T, A, D>>, t_set: Rc<dyn TraversibleBinaryTree<'a, T, A, D>>,
key: Rc<A>, key: A,
) -> T::F<()> { ) -> T::F<()> {
match t_set.refer() { match t_set.refer() {
Some(r_set) => r_contains(comparator, r_set, key), Some(r_set) => r_contains(comparator, r_set, key),

35
src/flow/traversible/algorithms/subset.rs
View File

@ -7,14 +7,14 @@ struct SubsetContext<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq> {
comparator: &'a dyn Comparator<A>, comparator: &'a dyn Comparator<A>,
n_subset: Rc<dyn TraversibleBinaryNode<'a, T, A, D>>, n_subset: Rc<dyn TraversibleBinaryNode<'a, T, A, D>>,
n_superset: Rc<dyn TraversibleBinaryNode<'a, T, A, D>>, n_superset: Rc<dyn TraversibleBinaryNode<'a, T, A, D>>,
k_l: Option<Rc<A>>, k_l: Option<A>,
k_r: Option<Rc<A>>, k_r: Option<A>,
t_superl: Rc<dyn TraversibleBinaryTree<'a, T, A, D>>, t_superl: Rc<dyn TraversibleBinaryTree<'a, T, A, D>>,
t_superr: Rc<dyn TraversibleBinaryTree<'a, T, A, D>>, t_superr: Rc<dyn TraversibleBinaryTree<'a, T, A, D>>,
k_super: Rc<A>, k_super: A,
} }
impl<'a, T: 'a + MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq> SubsetContext<'a, T, A, D> { impl<'a, T: 'a + MonadFail<'a, ()>, A: 'a + Clone, D: 'a + PartialEq> SubsetContext<'a, T, A, D> {
fn on_l(self, (t_subl, t_subr, k_sub): Split<'a, T, A, D>) -> T::F<()> { fn on_l(self, (t_subl, t_subr, k_sub): Split<'a, T, A, D>) -> T::F<()> {
T::la2( T::la2(
algorithms::contains::t_contains(self.comparator, self.t_superl.clone(), k_sub.clone()), algorithms::contains::t_contains(self.comparator, self.t_superl.clone(), k_sub.clone()),
@ -85,10 +85,7 @@ impl<'a, T: 'a + MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq> SubsetContext<'a,
fn test(self) -> T::F<()> { fn test(self) -> T::F<()> {
let split = self.n_subset.split(); let split = self.n_subset.split();
match self match self.comparator.pick_smaller(&split.2, &self.k_super) {
.comparator
.pick_smaller(split.2.as_ref(), self.k_super.as_ref())
{
Comparison::L => self.on_l(split), Comparison::L => self.on_l(split),
Comparison::E => self.on_e(split), Comparison::E => self.on_e(split),
Comparison::R => self.on_r(split), Comparison::R => self.on_r(split),
@ -96,21 +93,21 @@ impl<'a, T: 'a + MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq> SubsetContext<'a,
} }
} }
pub fn n_subset_of_n<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>( pub fn n_subset_of_n<'a, T: MonadFail<'a, ()>, A: 'a + Clone, D: 'a + PartialEq>(
comparator: &'a dyn Comparator<A>, comparator: &'a dyn Comparator<A>,
n_subset: Rc<dyn TraversibleBinaryNode<'a, T, A, D>>, n_subset: Rc<dyn TraversibleBinaryNode<'a, T, A, D>>,
n_superset: Rc<dyn TraversibleBinaryNode<'a, T, A, D>>, n_superset: Rc<dyn TraversibleBinaryNode<'a, T, A, D>>,
k_l: Option<Rc<A>>, k_l: Option<A>,
k_r: Option<Rc<A>>, k_r: Option<A>,
) -> T::F<()> { ) -> T::F<()> {
let (t_superl, t_superr, k_super) = n_superset.split(); let (t_superl, t_superr, k_super) = n_superset.split();
if let Some(ref a_l) = k_l { if let Some(ref a_l) = k_l {
if let Comparison::R = comparator.pick_smaller(a_l.as_ref(), k_super.as_ref()) { if let Comparison::R = comparator.pick_smaller(a_l, &k_super) {
return t_subset_of_t(comparator, n_subset.to_tree(), t_superr, k_l, k_r); return t_subset_of_t(comparator, n_subset.to_tree(), t_superr, k_l, k_r);
} }
} }
if let Some(ref a_r) = k_r { if let Some(ref a_r) = k_r {
if let Comparison::L = comparator.pick_smaller(a_r.as_ref(), k_super.as_ref()) { if let Comparison::L = comparator.pick_smaller(a_r, &k_super) {
return t_subset_of_t(comparator, n_subset.to_tree(), t_superl, k_l, k_r); return t_subset_of_t(comparator, n_subset.to_tree(), t_superl, k_l, k_r);
} }
} }
@ -127,12 +124,12 @@ pub fn n_subset_of_n<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>(
.test() .test()
} }
pub fn r_subset_of_r<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>( pub fn r_subset_of_r<'a, T: MonadFail<'a, ()>, A: 'a + Clone, D: 'a + PartialEq>(
comparator: &'a dyn Comparator<A>, comparator: &'a dyn Comparator<A>,
r_subset: Rc<dyn TraversibleBinaryReference<'a, T, A, D>>, r_subset: Rc<dyn TraversibleBinaryReference<'a, T, A, D>>,
r_superset: Rc<dyn TraversibleBinaryReference<'a, T, A, D>>, r_superset: Rc<dyn TraversibleBinaryReference<'a, T, A, D>>,
k_l: Option<Rc<A>>, k_l: Option<A>,
k_r: Option<Rc<A>>, k_r: Option<A>,
) -> T::F<()> { ) -> T::F<()> {
T::bind2( T::bind2(
r_subset.resolve(), r_subset.resolve(),
@ -141,12 +138,12 @@ pub fn r_subset_of_r<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>(
) )
} }
pub fn t_subset_of_t<'a, T: MonadFail<'a, ()>, A, D: 'a + PartialEq>( pub fn t_subset_of_t<'a, T: MonadFail<'a, ()>, A: 'a + Clone, D: 'a + PartialEq>(
comparator: &'a dyn Comparator<A>, comparator: &'a dyn Comparator<A>,
t_subset: Rc<dyn TraversibleBinaryTree<'a, T, A, D>>, t_subset: Rc<dyn TraversibleBinaryTree<'a, T, A, D>>,
t_superset: Rc<dyn TraversibleBinaryTree<'a, T, A, D>>, t_superset: Rc<dyn TraversibleBinaryTree<'a, T, A, D>>,
k_l: Option<Rc<A>>, k_l: Option<A>,
k_r: Option<Rc<A>>, k_r: Option<A>,
) -> T::F<()> { ) -> T::F<()> {
match (t_subset.refer(), t_superset.refer()) { match (t_subset.refer(), t_superset.refer()) {
(None, _) => T::pure(()), (None, _) => T::pure(()),

14
src/flow/traversible/unbalanced.rs
View File

@ -24,7 +24,7 @@ impl PartialEq for UnbalancedData {
pub struct UnbalancedNode<'a, T: Monad<'a>, A: 'a> { pub struct UnbalancedNode<'a, T: Monad<'a>, A: 'a> {
cl: Rc<UnbalancedTree<'a, T, A>>, cl: Rc<UnbalancedTree<'a, T, A>>,
cr: Rc<UnbalancedTree<'a, T, A>>, cr: Rc<UnbalancedTree<'a, T, A>>,
key: Rc<A>, key: A,
} }
pub type UnbalancedResolution<'a, T, A> = Wrap<'a, Rc<UnbalancedNode<'a, T, A>>, T>; pub type UnbalancedResolution<'a, T, A> = Wrap<'a, Rc<UnbalancedNode<'a, T, A>>, T>;
@ -76,7 +76,7 @@ impl<'a, A: 'a + Display> Display
} }
} }
impl<'a, T: Monad<'a>, A: 'a> TraversibleBinaryNode<'a, T, A, UnbalancedData> impl<'a, T: Monad<'a>, A: 'a + Clone> TraversibleBinaryNode<'a, T, A, UnbalancedData>
for UnbalancedNode<'a, T, A> for UnbalancedNode<'a, T, A>
{ {
fn split(&self) -> Split<'a, T, A, UnbalancedData> { fn split(&self) -> Split<'a, T, A, UnbalancedData> {
@ -90,7 +90,7 @@ impl<'a, T: Monad<'a>, A: 'a> TraversibleBinaryNode<'a, T, A, UnbalancedData>
} }
} }
impl<'a, T: Monad<'a>, A: 'a> TraversibleBinaryReference<'a, T, A, UnbalancedData> impl<'a, T: Monad<'a>, A: 'a + Clone> TraversibleBinaryReference<'a, T, A, UnbalancedData>
for UnbalancedReference<'a, T, A> for UnbalancedReference<'a, T, A>
{ {
fn resolve(&self) -> Wrap<'a, Rc<dyn TraversibleBinaryNode<'a, T, A, UnbalancedData>>, T> { fn resolve(&self) -> Wrap<'a, Rc<dyn TraversibleBinaryNode<'a, T, A, UnbalancedData>>, T> {
@ -104,7 +104,7 @@ impl<'a, T: Monad<'a>, A: 'a> TraversibleBinaryReference<'a, T, A, UnbalancedDat
} }
} }
impl<'a, T: Monad<'a>, A: 'a> TraversibleBinaryTree<'a, T, A, UnbalancedData> impl<'a, T: Monad<'a>, A: 'a + Clone> TraversibleBinaryTree<'a, T, A, UnbalancedData>
for UnbalancedTree<'a, T, A> for UnbalancedTree<'a, T, A>
{ {
fn refer(&self) -> Option<Rc<dyn TraversibleBinaryReference<'a, T, A, UnbalancedData>>> { fn refer(&self) -> Option<Rc<dyn TraversibleBinaryReference<'a, T, A, UnbalancedData>>> {
@ -138,11 +138,7 @@ impl<'a, T: Monad<'a>, A: 'a> UnbalancedConstructor<'a, T, A> {
key: A, key: A,
cr: Rc<UnbalancedTree<'a, T, A>>, cr: Rc<UnbalancedTree<'a, T, A>>,
) -> Rc<UnbalancedTree<'a, T, A>> { ) -> Rc<UnbalancedTree<'a, T, A>> {
let node = Rc::new(UnbalancedNode { let node = Rc::new(UnbalancedNode { cl, cr, key });
cl,
cr,
key: key.into(),
});
let ctr = self.clone(); let ctr = self.clone();
UnbalancedTree::Node(Rc::new(UnbalancedReference((ctr.wrap)(node)))).into() UnbalancedTree::Node(Rc::new(UnbalancedReference((ctr.wrap)(node)))).into()
} }