diff --git a/src/std/collections/rbtree.rs b/src/std/collections/rbtree.rs
index cff332d..3648ddb 100644
--- a/src/std/collections/rbtree.rs
+++ b/src/std/collections/rbtree.rs
@@ -1,4 +1,6 @@
-use std::{error::Error, fmt::Display};
+pub mod subset;
+
+use std::{rc::Rc, error::Error, fmt::Display};
 
 use crate::core::*;
 use crate::std::{
@@ -57,13 +59,13 @@ pub enum RBNode<'a, Ctx: 'a + Context, A: Mentionable<'a, Ctx>> {
 pub struct BNode<'a, Ctx: 'a + Context, A: Mentionable<'a, Ctx>> {
     cl: Nullable<'a, Ctx, RBNode<'a, Ctx, A>>,
     cr: Nullable<'a, Ctx, RBNode<'a, Ctx, A>>,
-    key: A,
+    key: Rc<A>,
 }
 
 pub struct RNode<'a, Ctx: 'a + Context, A: Mentionable<'a, Ctx>> {
     cl: Nullable<'a, Ctx, BNode<'a, Ctx, A>>,
     cr: Nullable<'a, Ctx, BNode<'a, Ctx, A>>,
-    key: A,
+    key: Rc<A>,
 }
 
 #[derive(Clone)]
@@ -222,7 +224,7 @@ impl<'a, Ctx: 'a + Context, F: Factory<'a, Ctx>> Factory<'a, Ctx> for BFactory<F
         let key = self
             .key_factory
             .deserialize(deserializer, resolver, addresses)
-            .map_err(TreeParseError::Key)?;
+            .map_err(TreeParseError::Key)?.into();
         Ok(BNode { cl, cr, key })
     }
 
@@ -250,7 +252,7 @@ impl<'a, Ctx: 'a + Context, F: Factory<'a, Ctx>> Factory<'a, Ctx> for RFactory<F
         let key = self
             .key_factory
             .deserialize(deserializer, resolver, addresses)
-            .map_err(TreeParseError::Key)?;
+            .map_err(TreeParseError::Key)?.into();
         Ok(RNode { cl, cr, key })
     }
 
diff --git a/src/std/collections/rbtree/subset.rs b/src/std/collections/rbtree/subset.rs
new file mode 100644
index 0000000..73cf1c2
--- /dev/null
+++ b/src/std/collections/rbtree/subset.rs
@@ -0,0 +1,168 @@
+use std::rc::Rc;
+
+use crate::flow::traversible::*;
+use crate::func::*;
+use crate::std::fallible::*;
+
+use super::*;
+
+pub type TPE<'a, Ctx, A> =
+    TreeParseError<<<A as Mentionable<'a, Ctx>>::Fctr as Factory<'a, Ctx>>::ParseError>;
+
+pub type TreeFaiure<'a, Ctx, A> =
+    ResolutionError<<Ctx as Context>::LookupError<'a>, TPE<'a, Ctx, A>>;
+
+pub type SubsetWrapped<'a, Ctx, A> = FallibleWrapped<'a, Ctx, bool, TreeFaiure<'a, Ctx, A>>;
+
+pub type SubsetMonad<'a, Ctx, A> = FallibleMonad<Ctx, TreeFaiure<'a, Ctx, A>>;
+
+pub fn subset_pure<'a, Ctx: 'a + Context, A: Mentionable<'a, Ctx>>(
+    value: bool,
+) -> SubsetWrapped<'a, Ctx, A> {
+    <SubsetMonad<'a, Ctx, A> as Pure>::pure(value)
+}
+
+#[derive(PartialEq)]
+enum NodeType {
+    Rb,
+    R,
+    B,
+}
+
+type RefData = (NodeType, Hash);
+
+impl<'a, Ctx: 'a + Context, A: Mentionable<'a, Ctx>>
+    TraversibleBinaryNode<'a, SubsetMonad<'a, Ctx, A>, A, RefData> for BNode<'a, Ctx, A>
+{
+    fn split(&self) -> Split<'a, SubsetMonad<'a, Ctx, A>, A, RefData> {
+        (
+            Rc::new(self.cl.clone()),
+            Rc::new(self.cr.clone()),
+            self.key.clone(),
+        )
+    }
+
+    fn to_tree(
+        self: Rc<Self>,
+    ) -> Rc<dyn TraversibleBinaryTree<'a, SubsetMonad<'a, Ctx, A>, A, RefData>> {
+        Rc::new(Nullable::from(self))
+    }
+}
+
+impl<'a, Ctx: 'a + Context, A: Mentionable<'a, Ctx>>
+    TraversibleBinaryNode<'a, SubsetMonad<'a, Ctx, A>, A, RefData> for RNode<'a, Ctx, A>
+{
+    fn split(&self) -> Split<'a, SubsetMonad<'a, Ctx, A>, A, RefData> {
+        (
+            Rc::new(self.cl.clone()),
+            Rc::new(self.cr.clone()),
+            self.key.clone(),
+        )
+    }
+
+    fn to_tree(
+        self: Rc<Self>,
+    ) -> Rc<dyn TraversibleBinaryTree<'a, SubsetMonad<'a, Ctx, A>, A, RefData>> {
+        Rc::new(Nullable::from(self))
+    }
+}
+
+impl<'a, Ctx: 'a + Context, A: Mentionable<'a, Ctx>>
+    TraversibleBinaryNode<'a, SubsetMonad<'a, Ctx, A>, A, RefData> for RBNode<'a, Ctx, A>
+{
+    fn split(&self) -> Split<'a, SubsetMonad<'a, Ctx, A>, A, RefData> {
+        match self {
+            RBNode::R(r) => r.split(),
+            RBNode::B(b) => b.split(),
+        }
+    }
+
+    fn to_tree(
+        self: Rc<Self>,
+    ) -> Rc<dyn TraversibleBinaryTree<'a, SubsetMonad<'a, Ctx, A>, A, RefData>> {
+        Rc::new(Nullable::from(self))
+    }
+}
+
+impl<'a, Ctx: 'a + Context, A: Mentionable<'a, Ctx>>
+    TraversibleBinaryReference<'a, SubsetMonad<'a, Ctx, A>, A, RefData>
+    for Point<'a, Ctx, BNode<'a, Ctx, A>>
+{
+    fn resolve(
+        &self,
+    ) -> <SubsetMonad<'a, Ctx, A> as WeakFunctor>::F<
+        'a,
+        Rc<dyn TraversibleBinaryNode<'a, SubsetMonad<'a, Ctx, A>, A, RefData>>,
+    > {
+        <SubsetMonad<'a, Ctx, A> as Functor>::fmap(
+            |resolved| resolved as Rc<dyn TraversibleBinaryNode<'a, _, _, _>>,
+            self.resolve(),
+        )
+    }
+
+    fn data(&self) -> RefData {
+        (NodeType::B, self.point)
+    }
+}
+
+impl<'a, Ctx: 'a + Context, A: Mentionable<'a, Ctx>>
+    TraversibleBinaryReference<'a, SubsetMonad<'a, Ctx, A>, A, RefData>
+    for Point<'a, Ctx, RNode<'a, Ctx, A>>
+{
+    fn resolve(
+        &self,
+    ) -> <SubsetMonad<'a, Ctx, A> as WeakFunctor>::F<
+        'a,
+        Rc<dyn TraversibleBinaryNode<'a, SubsetMonad<'a, Ctx, A>, A, RefData>>,
+    > {
+        <SubsetMonad<'a, Ctx, A> as Functor>::fmap(
+            |resolved| resolved as Rc<dyn TraversibleBinaryNode<'a, _, _, _>>,
+            self.resolve(),
+        )
+    }
+
+    fn data(&self) -> RefData {
+        (NodeType::R, self.point)
+    }
+}
+
+impl<'a, Ctx: 'a + Context, A: Mentionable<'a, Ctx>>
+    TraversibleBinaryReference<'a, SubsetMonad<'a, Ctx, A>, A, RefData>
+    for Point<'a, Ctx, RBNode<'a, Ctx, A>>
+{
+    fn resolve(
+        &self,
+    ) -> <SubsetMonad<'a, Ctx, A> as WeakFunctor>::F<
+        'a,
+        Rc<dyn TraversibleBinaryNode<'a, SubsetMonad<'a, Ctx, A>, A, RefData>>,
+    > {
+        <SubsetMonad<'a, Ctx, A> as Functor>::fmap(
+            |resolved| resolved as Rc<dyn TraversibleBinaryNode<'a, _, _, _>>,
+            self.resolve(),
+        )
+    }
+
+    fn data(&self) -> RefData {
+        (NodeType::Rb, self.point)
+    }
+}
+
+impl<
+        'a,
+        Ctx: 'a + Context,
+        A: Mentionable<'a, Ctx>,
+        T: Mentionable<'a, Ctx>,
+        D: 'a + PartialEq,
+    > TraversibleBinaryTree<'a, SubsetMonad<'a, Ctx, A>, A, D> for Nullable<'a, Ctx, T>
+where
+    Point<'a, Ctx, T>: TraversibleBinaryReference<'a, SubsetMonad<'a, Ctx, A>, A, D>,
+{
+    fn refer(
+        &self,
+    ) -> Option<Rc<dyn TraversibleBinaryReference<'a, SubsetMonad<'a, Ctx, A>, A, D>>> {
+        match self {
+            Nullable::Null(_) => None,
+            Nullable::NotNull(point) => Some(Rc::new(point.clone())),
+        }
+    }
+}