Struct BstNodeRef 

pub struct BstNodeRef<BorrowType, Spec>
where
    Spec: BstSpec,
{
    pub node: NonNull<BstNode<Spec::Data, Spec::Parent>>,
    _marker: PhantomData<BorrowType>,
}

Fields

node: NonNull<BstNode<Spec::Data, Spec::Parent>>

_marker: PhantomData<BorrowType>

Implementations

impl<BorrowType, Spec> BstNodeRef<BorrowType, Spec>

where Spec: BstSpec, BorrowType: BorrowType,

pub unsafe fn new_unchecked( node: NonNull<BstNode<Spec::Data, Spec::Parent>>, ) -> Self

Examples found in repository

crates/competitive/src/tree/top_tree.rs (line 369)

    unsafe fn pull_top(node: TopPtr<S, A>) {
        unsafe { TopBstSpec::<S, A>::bottom_up(BstDataMutRef::new_unchecked(node)) };
    }

    #[inline]
    unsafe fn pull_rake(node: RakePtr<S, A>) {
        unsafe { RakeBstSpec::<S, A>::bottom_up(BstDataMutRef::new_unchecked(node)) };
    }

    #[inline]
    unsafe fn splay_top(node: TopPtr<S, A>) {
        let root = if A::ROOT_TO_NODE_TOP_DOWN {
            unsafe {
                splay_operations::with_parent::splay::<TopBstSpec<S, A>, TopTreeData<S, A>>(node)
            }
        } else {
            unsafe {
                splay_operations::with_parent::splay_with_local_top_down::<
                    TopBstSpec<S, A>,
                    TopTreeData<S, A>,
                >(node)
            }
        };
        if root != node {
            unsafe {
                (*node.as_ptr()).data.belong = (*root.as_ptr()).data.belong.take();
            }
        }
    }

    #[inline]
    unsafe fn splay_rake(node: RakePtr<S, A>) {
        unsafe {
            splay_operations::with_parent::splay_with_local_top_down::<
                RakeBstSpec<S, A>,
                RakeData<S, A>,
            >(node)
        };
    }

    unsafe fn rake_rightmost(mut node: RakePtr<S, A>) -> RakePtr<S, A> {
        loop {
            unsafe { RakeBstSpec::<S, A>::top_down(BstDataMutRef::new_unchecked(node)) };
            match unsafe { node.as_ref().child[1] } {
                Some(right) => node = right,
                None => return node,
            }
        }
    }

    unsafe fn rake_insert(
        &mut self,
        root: Option<RakePtr<S, A>>,
        key: S::Point,
    ) -> (RakePtr<S, A>, RakePtr<S, A>) {
        let mut node = self.rake_allocator.allocate(BstNode::new(RakeData {
            sum: key.clone(),
            key,
            action: <A::ActionMonoid as Unital>::unit(),
            buffer: <A::ActionMonoid as Unital>::unit(),
        }));
        if let Some(mut root) = root {
            unsafe {
                node.as_mut().child[0] = Some(root);
                root.as_mut().parent.parent = Some(node);
                Self::pull_rake(node);
            }
        }
        (node, node)
    }

    unsafe fn rake_remove(
        &mut self,
        mut node: RakePtr<S, A>,
    ) -> (Option<RakePtr<S, A>>, A::Action) {
        unsafe {
            Self::splay_rake(node);
            RakeBstSpec::<S, A>::top_down(BstDataMutRef::new_unchecked(node));
        }
        let left = unsafe { node.as_mut().child[0].take() };
        let right = unsafe { node.as_mut().child[1].take() };
        for mut child in [left, right].into_iter().flatten() {
            unsafe { child.as_mut().parent.parent = None };
        }
        let root = match (left, right) {
            (None, right) => right,
            (left, None) => left,
            (Some(left), Some(right)) => {
                let mut root = unsafe { Self::rake_rightmost(left) };
                unsafe {
                    Self::splay_rake(root);
                    root.as_mut().child[1] = Some(right);
                    (*right.as_ptr()).parent.parent = Some(root);
                    Self::pull_rake(root);
                }
                Some(root)
            }
        };
        let node = self.rake_allocator.deallocate(node);
        (root, node.data.buffer)
    }

    fn access_node(&mut self, node: TopPtr<S, A>) {
        unsafe {
            let mut previous: Option<TopPtr<S, A>> = None;
            let mut current = Some(node);
            while let Some(mut cursor) = current {
                Self::splay_top(cursor);
                let next = cursor.as_ref().parent.parent;
                if let Some(right) = cursor.as_mut().child[1].take() {
                    let point = S::add_edge(&right.as_ref().data.sum);
                    let (light, entry) = self.rake_insert(cursor.as_ref().data.light, point);
                    cursor.as_mut().data.light = Some(light);
                    (*right.as_ptr()).data.belong = Some(entry);
                }
                if let Some(previous) = previous {
                    let entry = (*previous.as_ptr())
                        .data
                        .belong
                        .take()
                        .expect("a virtual path must have a rake-tree entry");
                    let (light, action) = self.rake_remove(entry);
                    cursor.as_mut().data.light = light;
                    TopBstSpec::<S, A>::apply_all(previous, &action);
                    cursor.as_mut().child[1] = Some(previous);
                    (*previous.as_ptr()).parent.parent = Some(cursor);
                }
                Self::pull_top(cursor);
                previous = Some(cursor);
                current = next;
            }
            Self::splay_top(node);
        }
    }

    pub fn get(&mut self, node: usize) -> &S::Info {
        let node = self.node(node);
        self.access_node(node);
        unsafe { &node.as_ref().data.info }
    }

    pub fn set(&mut self, node: usize, info: S::Info) {
        self.modify(node, |_| info);
    }

    pub fn modify<F>(&mut self, node: usize, f: F)
    where
        F: FnOnce(&S::Info) -> S::Info,
    {
        let mut node = self.node(node);
        self.access_node(node);
        unsafe {
            node.as_mut().data.info = f(&node.as_ref().data.info);
            Self::pull_top(node);
        }
    }

    pub fn reroot(&mut self, node: usize) {
        let node = self.node(node);
        self.access_node(node);
        unsafe { TopBstSpec::<S, A>::toggle(node) };
    }

    /// `child` and `parent` must belong to different trees.
    pub fn link(&mut self, child: usize, parent: usize) {
        assert_ne!(child, parent);
        self.reroot(child);
        let child = self.node(child);
        let mut parent = self.node(parent);
        self.access_node(parent);
        unsafe {
            (*child.as_ptr()).parent.parent = Some(parent);
            let point = S::add_edge(&child.as_ref().data.sum);
            let (light, entry) = self.rake_insert(parent.as_ref().data.light, point);
            parent.as_mut().data.light = Some(light);
            (*child.as_ptr()).data.belong = Some(entry);
            Self::pull_top(parent);
        }
    }

    /// `(u, v)` must be an edge.
    pub fn cut(&mut self, u: usize, v: usize) {
        assert_ne!(u, v);
        self.reroot(u);
        let mut v = self.node(v);
        self.access_node(v);
        unsafe {
            let mut left = v.as_mut().child[0]
                .take()
                .expect("the specified edge must exist");
            left.as_mut().parent.parent = None;
            Self::pull_top(v);
        }
    }

    pub fn root(&mut self, node: usize) -> usize {
        let mut root = self.node(node);
        self.access_node(root);
        unsafe {
            loop {
                TopBstSpec::<S, A>::top_down(BstDataMutRef::new_unchecked(root));
                match root.as_ref().child[0] {
                    Some(left) => root = left,
                    None => break,
                }
            }
            Self::splay_top(root);
            root.as_ref().data.index_and_reverse >> 1
        }
    }

    pub fn is_connected(&mut self, u: usize, v: usize) -> bool {
        self.root(u) == self.root(v)
    }

    /// `u` and `v` must be connected.
    pub fn fold_path(&mut self, u: usize, v: usize) -> S::Path {
        self.reroot(u);
        let v = self.node(v);
        self.access_node(v);
        unsafe { v.as_ref().data.sum.clone() }
    }

    /// `u` and `v` must be connected.
    pub fn update_path(&mut self, u: usize, v: usize, action: &A::Action) {
        self.reroot(u);
        let v = self.node(v);
        self.access_node(v);
        if !TopBstSpec::<S, A>::is_unit(action) {
            unsafe { TopBstSpec::<S, A>::apply_heavy(v, action) };
        }
    }

    fn detach_left<R>(mut node: TopPtr<S, A>, f: impl FnOnce(TopPtr<S, A>) -> R) -> R {
        unsafe {
            let left = node.as_mut().child[0].take();
            if let Some(mut left) = left {
                left.as_mut().parent.parent = None;
            }
            Self::pull_top(node);
            let result = f(node);
            node.as_mut().child[0] = left;
            if let Some(mut left) = left {
                left.as_mut().parent.parent = Some(node);
            }
            Self::pull_top(node);
            result
        }
    }

    /// `(node, parent)` must be an edge.
    pub fn fold_subtree(&mut self, node: usize, parent: usize) -> S::Path {
        self.reroot(parent);
        let node = self.node(node);
        self.access_node(node);
        Self::detach_left(node, |node| unsafe { node.as_ref().data.sum.clone() })
    }

    /// `(node, parent)` must be an edge.
    pub fn update_subtree(&mut self, node: usize, parent: usize, action: &A::Action) {
        self.reroot(parent);
        let node = self.node(node);
        self.access_node(node);
        Self::detach_left(node, |node| unsafe {
            TopBstSpec::<S, A>::apply_all(node, action);
            TopBstSpec::<S, A>::top_down(BstDataMutRef::new_unchecked(node));
        });
    }

crates/competitive/src/tree/link_cut_tree.rs (line 208)

    unsafe fn pull(node: LinkCutPtr<S>) {
        unsafe {
            LinkCutBstSpec::<S>::bottom_up(BstDataMutRef::new_unchecked(node));
        }
    }

    #[inline]
    unsafe fn splay(node: LinkCutPtr<S>) {
        let root = if S::ROOT_TO_NODE_TOP_DOWN {
            unsafe {
                splay_operations::with_parent::splay::<LinkCutBstSpec<S>, LinkCutData<S>>(node)
            }
        } else {
            unsafe {
                splay_operations::with_parent::splay_with_local_top_down::<
                    LinkCutBstSpec<S>,
                    LinkCutData<S>,
                >(node)
            }
        };
        if root != node {
            unsafe {
                LinkCutBstSpec::<S>::with_two_inner_mut(root, node, S::transfer_path_parent);
            }
        }
    }

    fn access_node(mut node: LinkCutPtr<S>) {
        unsafe {
            Self::splay(node);
            if let Some(right) = node.as_mut().child[1].take() {
                LinkCutBstSpec::<S>::with_two_inner_mut(node, right, S::attach_virtual);
            }
            Self::pull(node);
            while let Some(mut parent) = node.as_ref().parent.parent {
                Self::splay(parent);
                if let Some(right) = parent.as_mut().child[1].take() {
                    LinkCutBstSpec::<S>::with_two_inner_mut(parent, right, S::attach_virtual);
                }
                LinkCutBstSpec::<S>::with_two_inner_mut(parent, node, S::detach_virtual);
                parent.as_mut().child[1] = Some(node);
                node.as_mut().parent.parent = Some(parent);
                LinkCutBstSpec::<S>::top_down(BstDataMutRef::new_unchecked(node));
                splay_operations::with_parent::rotate::<LinkCutBstSpec<S>, LinkCutData<S>>(node);
                Self::pull(node);
                LinkCutBstSpec::<S>::with_two_inner_mut(parent, node, S::transfer_path_parent);
            }
        }
    }

    pub fn get(&mut self, node: usize) -> &S::Value {
        let node = self.node(node);
        Self::access_node(node);
        unsafe { S::value(&node.as_ref().data.inner) }
    }

    pub fn set(&mut self, node: usize, value: S::Value) {
        self.modify(node, |_| value);
    }

    pub fn modify<F>(&mut self, node: usize, f: F)
    where
        F: FnOnce(&S::Value) -> S::Value,
    {
        let node = self.node(node);
        if S::MODIFY_REQUIRES_ACCESS {
            Self::access_node(node);
        } else {
            unsafe { Self::splay(node) };
        }
        unsafe {
            let data = &mut (*node.as_ptr()).data.inner;
            *S::value_mut(data) = f(S::value(data));
            Self::pull(node);
        }
    }

    pub fn reroot(&mut self, node: usize) {
        let node = self.node(node);
        Self::access_node(node);
        unsafe { LinkCutBstSpec::<S>::toggle(node) };
    }

    /// `child` and `parent` must belong to different trees.
    pub fn link(&mut self, child: usize, parent: usize) {
        assert_ne!(child, parent);
        self.reroot(child);
        let child = self.node(child);
        let parent = self.node(parent);
        Self::access_node(parent);
        unsafe {
            (*child.as_ptr()).parent.parent = Some(parent);
            LinkCutBstSpec::<S>::with_two_inner_mut(parent, child, S::attach_virtual);
            Self::pull(parent);
        }
    }

    /// `(u, v)` must be an edge.
    pub fn cut(&mut self, u: usize, v: usize) {
        assert_ne!(u, v);
        self.reroot(u);
        let mut v = self.node(v);
        Self::access_node(v);
        unsafe {
            let mut left = v.as_mut().child[0]
                .take()
                .expect("the specified edge must exist");
            left.as_mut().parent.parent = None;
            Self::pull(v);
        }
    }

    pub fn root(&mut self, node: usize) -> usize {
        let mut root = self.node(node);
        Self::access_node(root);
        unsafe {
            loop {
                LinkCutBstSpec::<S>::top_down(BstDataMutRef::new_unchecked(root));
                match root.as_ref().child[0] {
                    Some(left) => root = left,
                    None => break,
                }
            }
            Self::splay(root);
            root.as_ref().data.index_and_reverse >> 1
        }
    }

    pub fn is_connected(&mut self, u: usize, v: usize) -> bool {
        self.root(u) == self.root(v)
    }

    fn detach_left<R>(node: LinkCutPtr<S>, f: impl FnOnce(&mut S::Data) -> R) -> R {
        unsafe {
            let left = (*node.as_ptr()).child[0].take();
            if let Some(mut left) = left {
                left.as_mut().parent.parent = None;
            }
            Self::pull(node);
            let result = f(&mut (*node.as_ptr()).data.inner);
            LinkCutBstSpec::<S>::top_down(BstDataMutRef::new_unchecked(node));
            (*node.as_ptr()).child[0] = left;
            if let Some(mut left) = left {
                left.as_mut().parent.parent = Some(node);
            }
            Self::pull(node);
            result
        }
    }

crates/competitive/src/data_structure/binary_search_tree/node_id.rs (line 57)

    pub unsafe fn reborrow<'a>(
        self,
        _root: &'a Option<BstRoot<Spec>>,
    ) -> BstNodeRef<node::marker::Immut<'a>, Spec> {
        unsafe { BstNodeRef::new_unchecked(self.node) }
    }

    pub unsafe fn reborrow_datamut<'a>(
        self,
        _root: &'a mut Option<BstRoot<Spec>>,
    ) -> BstNodeRef<node::marker::DataMut<'a>, Spec> {
        unsafe { BstNodeRef::new_unchecked(self.node) }
    }

    pub unsafe fn reborrow_mut<'a>(
        self,
        _root: &'a mut Option<BstRoot<Spec>>,
    ) -> BstNodeRef<node::marker::Mut<'a>, Spec> {
        unsafe { BstNodeRef::new_unchecked(self.node) }
    }

crates/competitive/src/data_structure/splay_operations.rs (line 65)

    pub unsafe fn rotate<Spec, Data>(mut node: NodePtr<Spec>)
    where
        Spec: BstSpec<Data = Data, Parent = WithParent<Data>>,
    {
        let (parent, direction) = unsafe { internal_parent::<Spec, Data>(node) }
            .expect("an auxiliary root cannot be rotated");
        unsafe {
            node.as_mut().parent.parent = parent.as_ref().parent.parent;
            if let Ok((mut grandparent, direction)) = internal_parent::<Spec, Data>(parent) {
                grandparent.as_mut().child[direction] = Some(node);
            }
            rotate_at::<Spec, Data>(node, parent, direction);
            Spec::bottom_up(BstDataMutRef::new_unchecked(parent));
        }
    }

    /// Moves `node` to the root of its auxiliary tree and returns the previous root.
    ///
    /// # Safety
    ///
    /// `node` and every pointer reachable through its auxiliary-parent chain must
    /// refer to live nodes of the same tree.
    #[inline(always)]
    pub unsafe fn splay<Spec, Data>(node: NodePtr<Spec>) -> NodePtr<Spec>
    where
        Spec: BstSpec<Data = Data, Parent = WithParent<Data>>,
    {
        let mut inline_stack = [const { MaybeUninit::uninit() }; 64];
        let mut inline_len = 0;
        let mut overflow_stack = Vec::new();
        let mut current = node;
        loop {
            if inline_len < inline_stack.len() {
                inline_stack[inline_len].write(current);
                inline_len += 1;
            } else {
                overflow_stack.push(current);
            }
            match unsafe { internal_parent::<Spec, Data>(current) } {
                Ok((parent, _)) => current = parent,
                Err(_) => break,
            }
        }
        for &node in overflow_stack.iter().rev() {
            unsafe { Spec::top_down(BstDataMutRef::new_unchecked(node)) };
        }
        while inline_len > 0 {
            inline_len -= 1;
            unsafe {
                Spec::top_down(BstDataMutRef::new_unchecked(
                    *inline_stack[inline_len].assume_init_ref(),
                ));
            }
        }

        while let Ok((parent, node_direction)) = unsafe { internal_parent::<Spec, Data>(node) } {
            if let Ok((_, parent_direction)) = unsafe { internal_parent::<Spec, Data>(parent) } {
                if node_direction == parent_direction {
                    unsafe { rotate::<Spec, Data>(parent) };
                } else {
                    unsafe { rotate::<Spec, Data>(node) };
                }
            }
            unsafe { rotate::<Spec, Data>(node) };
        }
        unsafe { Spec::bottom_up(BstDataMutRef::new_unchecked(node)) };
        current
    }

    /// Moves `node` to the root by propagating only the nodes involved in each rotation and
    /// returns the previous root.
    ///
    /// # Safety
    ///
    /// `node` and every pointer reachable through its auxiliary-parent chain must refer to live
    /// nodes of the same tree. Propagating an ancestor after its descendant must be valid for
    /// `Spec`.
    #[inline(always)]
    pub unsafe fn splay_with_local_top_down<Spec, Data>(mut node: NodePtr<Spec>) -> NodePtr<Spec>
    where
        Spec: BstSpec<Data = Data, Parent = WithParent<Data>>,
    {
        let mut current = node;
        unsafe { Spec::top_down(BstDataMutRef::new_unchecked(node)) };
        while let Ok((parent, _)) = unsafe { internal_parent::<Spec, Data>(node) } {
            match unsafe { internal_parent::<Spec, Data>(parent) } {
                Ok((grandparent, _)) => {
                    current = grandparent;
                    unsafe {
                        Spec::top_down(BstDataMutRef::new_unchecked(grandparent));
                        Spec::top_down(BstDataMutRef::new_unchecked(parent));
                        Spec::top_down(BstDataMutRef::new_unchecked(node));
                        let node_direction = usize::from(parent.as_ref().child[1] == Some(node));
                        let parent_direction =
                            usize::from(grandparent.as_ref().child[1] == Some(parent));
                        node.as_mut().parent.parent = grandparent.as_ref().parent.parent;
                        if let Ok((mut ancestor, direction)) =
                            internal_parent::<Spec, Data>(grandparent)
                        {
                            ancestor.as_mut().child[direction] = Some(node);
                        }
                        if node_direction == parent_direction {
                            rotate_at::<Spec, Data>(parent, grandparent, parent_direction);
                            rotate_at::<Spec, Data>(node, parent, node_direction);
                            Spec::bottom_up(BstDataMutRef::new_unchecked(grandparent));
                            Spec::bottom_up(BstDataMutRef::new_unchecked(parent));
                        } else {
                            rotate_at::<Spec, Data>(node, parent, node_direction);
                            rotate_at::<Spec, Data>(node, grandparent, parent_direction);
                            Spec::bottom_up(BstDataMutRef::new_unchecked(parent));
                            Spec::bottom_up(BstDataMutRef::new_unchecked(grandparent));
                        }
                    }
                }
                Err(ancestor) => {
                    current = parent;
                    unsafe {
                        Spec::top_down(BstDataMutRef::new_unchecked(parent));
                        Spec::top_down(BstDataMutRef::new_unchecked(node));
                        let direction = usize::from(parent.as_ref().child[1] == Some(node));
                        node.as_mut().parent.parent = ancestor;
                        rotate_at::<Spec, Data>(node, parent, direction);
                        Spec::bottom_up(BstDataMutRef::new_unchecked(parent));
                    }
                }
            }
        }
        unsafe { Spec::bottom_up(BstDataMutRef::new_unchecked(node)) };
        current
    }

pub fn reborrow(&self) -> BstNodeRef<Immut<'_>, Spec>

Examples found in repository

crates/competitive/src/data_structure/binary_search_tree/split.rs (line 41)

    pub fn left(&self) -> Option<BstImmutRef<'_, Spec>> {
        self.left.as_ref().map(|node| node.reborrow())
    }

    pub fn right(&self) -> Option<BstImmutRef<'_, Spec>> {
        self.right.as_ref().map(|node| node.reborrow())
    }

    pub fn left_datamut(&mut self) -> Option<BstDataMutRef<'_, Spec>> {
        self.left.as_mut().map(|node| node.borrow_datamut())
    }

    pub fn right_datamut(&mut self) -> Option<BstDataMutRef<'_, Spec>> {
        self.right.as_mut().map(|node| node.borrow_datamut())
    }

    pub fn manually_merge<F>(&mut self, mut f: F)
    where
        F: FnMut(Option<BstRoot<Spec>>, Option<BstRoot<Spec>>) -> Option<BstRoot<Spec>>,
    {
        self.left = f(self.left.take(), self.right.take());
    }
}

impl<'a, Spec> Drop for Split<'a, Spec>
where
    Spec: BstSpec,
{
    fn drop(&mut self) {
        *self.root = Spec::merge(self.left.take(), self.right.take());
    }
}

pub struct Split3<'a, Spec>
where
    Spec: BstSpec,
{
    left: Option<BstRoot<Spec>>,
    mid: Option<BstRoot<Spec>>,
    right: Option<BstRoot<Spec>>,
    root: &'a mut Option<BstRoot<Spec>>,
}

impl<'a, Spec> Split3<'a, Spec>
where
    Spec: BstSpec,
{
    pub fn new<Seek1, Seek2>(
        node: &'a mut Option<BstRoot<Spec>>,
        start: Bound<Seek1>,
        end: Bound<Seek2>,
    ) -> Self
    where
        Seek1: BstSeeker<Spec = Spec>,
        Seek2: BstSeeker<Spec = Spec>,
    {
        let (mut rest, right) = match end {
            Bound::Included(seeker) => Spec::split(node.take(), seeker, EqualSide::Left),
            Bound::Excluded(seeker) => Spec::split(node.take(), seeker, EqualSide::Right),
            Bound::Unbounded => (node.take(), None),
        };
        let (left, mid) = match start {
            Bound::Included(seeker) => Spec::split(rest.take(), seeker, EqualSide::Right),
            Bound::Excluded(seeker) => Spec::split(rest.take(), seeker, EqualSide::Left),
            Bound::Unbounded => (None, rest),
        };
        Self {
            left,
            mid,
            right,
            root: node,
        }
    }

    pub fn left(&self) -> Option<BstImmutRef<'_, Spec>> {
        self.left.as_ref().map(|node| node.reborrow())
    }

    pub fn mid(&self) -> Option<BstImmutRef<'_, Spec>> {
        self.mid.as_ref().map(|node| node.reborrow())
    }

    pub fn right(&self) -> Option<BstImmutRef<'_, Spec>> {
        self.right.as_ref().map(|node| node.reborrow())
    }

crates/competitive/src/data_structure/binary_search_tree/seeker.rs (line 29)

    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        if node.reborrow().left().descend().is_ok() {
            Ordering::Greater
        } else {
            Ordering::Equal
        }
    }
}

pub struct SeekRight<Spec> {
    _marker: PhantomData<fn() -> Spec>,
}

impl<S> Default for SeekRight<S> {
    fn default() -> Self {
        Self {
            _marker: PhantomData,
        }
    }
}

impl<Spec> BstSeeker for SeekRight<Spec>
where
    Spec: BstSpec,
{
    type Spec = Spec;
    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        if node.reborrow().right().descend().is_ok() {
            Ordering::Less
        } else {
            Ordering::Equal
        }
    }
}

pub struct SeekByKey<'a, Spec, K, Q>
where
    Q: ?Sized,
{
    key: &'a Q,
    _marker: PhantomData<fn() -> (Spec, K)>,
}

impl<'a, Spec, K, Q> SeekByKey<'a, Spec, K, Q>
where
    Q: ?Sized,
{
    pub fn new(key: &'a Q) -> Self {
        Self {
            key,
            _marker: PhantomData,
        }
    }
}

impl<Spec, K, Q> BstSeeker for SeekByKey<'_, Spec, K, Q>
where
    Spec: BstSpec<Data: BstDataAccess<data::marker::Key, Value = K>>,
    K: Borrow<Q>,
    Q: Ord + ?Sized,
{
    type Spec = Spec;

    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        node.reborrow()
            .into_data()
            .bst_data()
            .borrow()
            .cmp(self.key)
    }
}

pub struct SeekBySize<Spec> {
    index: usize,
    _marker: PhantomData<fn() -> Spec>,
}

impl<Spec> SeekBySize<Spec> {
    pub fn new(index: usize) -> Self {
        Self {
            index,
            _marker: PhantomData,
        }
    }
}

impl<Spec> BstSeeker for SeekBySize<Spec>
where
    Spec: BstSpec<Data: BstDataAccess<data::marker::Size, Value = usize>>,
{
    type Spec = Spec;

    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        let lsize = node
            .reborrow()
            .left()
            .descend()
            .map(|l| *l.into_data().bst_data())
            .unwrap_or_default();
        let ord = lsize.cmp(&self.index);
        if matches!(ord, Ordering::Less) {
            self.index -= lsize + 1;
        }
        ord
    }
}

pub struct SeekByAccCond<Spec, L, F>
where
    L: LazyMapMonoid,
{
    acc: L::Agg,
    f: F,
    _marker: PhantomData<fn() -> (Spec, L)>,
}

impl<Spec, L, F> SeekByAccCond<Spec, L, F>
where
    L: LazyMapMonoid,
    F: FnMut(&L::Agg) -> bool,
{
    pub fn new(f: F) -> Self {
        Self {
            acc: L::agg_unit(),
            f,
            _marker: PhantomData,
        }
    }
}

impl<Spec, L, F> BstSeeker for SeekByAccCond<Spec, L, F>
where
    Spec: BstSpec<Data: BstDataAccess<data::marker::LazyMap, Value = LazyMapElement<L>>>,
    L: LazyMapMonoid,
    F: FnMut(&L::Agg) -> bool,
{
    type Spec = Spec;

    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        if let Ok(left) = node.reborrow().left().descend() {
            let left_agg = &left.into_data().bst_data().agg;
            let nagg = L::agg_operate(&self.acc, left_agg);
            if (self.f)(&nagg) {
                return Ordering::Greater;
            }
            let nagg = L::agg_operate(
                &nagg,
                &L::single_agg(&node.reborrow().into_data().bst_data().key),
            );
            if (self.f)(&nagg) {
                Ordering::Equal
            } else {
                self.acc = nagg;
                Ordering::Less
            }
        } else {
            let nagg = L::agg_operate(
                &self.acc,
                &L::single_agg(&node.reborrow().into_data().bst_data().key),
            );
            if (self.f)(&nagg) {
                Ordering::Equal
            } else {
                self.acc = nagg;
                Ordering::Less
            }
        }
    }
}

pub struct SeekByRaccCond<Spec, L, F>
where
    L: LazyMapMonoid,
{
    acc: L::Agg,
    f: F,
    _marker: PhantomData<fn() -> (Spec, L)>,
}

impl<Spec, L, F> SeekByRaccCond<Spec, L, F>
where
    L: LazyMapMonoid,
    F: FnMut(&L::Agg) -> bool,
{
    pub fn new(f: F) -> Self {
        Self {
            acc: L::agg_unit(),
            f,
            _marker: PhantomData,
        }
    }
}

impl<Spec, L, F> BstSeeker for SeekByRaccCond<Spec, L, F>
where
    Spec: BstSpec<Data: BstDataAccess<data::marker::LazyMap, Value = LazyMapElement<L>>>,
    L: LazyMapMonoid,
    F: FnMut(&L::Agg) -> bool,
{
    type Spec = Spec;

    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        if let Ok(right) = node.reborrow().right().descend() {
            let right_agg = &right.into_data().bst_data().agg;
            let nagg = L::agg_operate(right_agg, &self.acc);
            if (self.f)(&nagg) {
                return Ordering::Less;
            }
            let nagg = L::agg_operate(
                &L::single_agg(&node.reborrow().into_data().bst_data().key),
                &nagg,
            );
            if (self.f)(&nagg) {
                Ordering::Equal
            } else {
                self.acc = nagg;
                Ordering::Greater
            }
        } else {
            let nagg = L::agg_operate(
                &L::single_agg(&node.reborrow().into_data().bst_data().key),
                &self.acc,
            );
            if (self.f)(&nagg) {
                Ordering::Equal
            } else {
                self.acc = nagg;
                Ordering::Greater
            }
        }
    }

crates/competitive/src/data_structure/splay_tree.rs (line 80)

    fn bottom_up(mut node: BstDataMutRef<'_, Self>) {
        let left = node
            .reborrow()
            .left()
            .descend()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        let right = node
            .reborrow()
            .right()
            .descend()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        node.data_mut().size = left + right + 1;
    }

    #[inline]
    fn merge(
        left: Option<SplayTreeRoot<K, V>>,
        right: Option<SplayTreeRoot<K, V>>,
    ) -> Option<SplayTreeRoot<K, V>> {
        splay_operations::merge(left, right)
    }

    #[inline]
    fn split<Seeker>(
        node: Option<SplayTreeRoot<K, V>>,
        seeker: Seeker,
        equal_side: EqualSide,
    ) -> (Option<SplayTreeRoot<K, V>>, Option<SplayTreeRoot<K, V>>)
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        splay_operations::split(node, seeker, equal_side)
    }
}

pub struct SplayTree<K, V, A = MemoryPool<SplayTreeNode<K, V>>>
where
    A: Allocator<SplayTreeNode<K, V>>,
{
    root: Option<SplayTreeRoot<K, V>>,
    length: usize,
    allocator: ManuallyDrop<A>,
}

impl<K, V, A> Debug for SplayTree<K, V, A>
where
    K: Debug,
    V: Debug,
    A: Allocator<SplayTreeNode<K, V>>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("SplayTree")
            .field("length", &self.length)
            .finish_non_exhaustive()
    }
}

impl<K, V, A> Default for SplayTree<K, V, A>
where
    A: Allocator<SplayTreeNode<K, V>> + Default,
{
    fn default() -> Self {
        Self {
            root: None,
            length: 0,
            allocator: ManuallyDrop::new(A::default()),
        }
    }
}

impl<K, V, A> Drop for SplayTree<K, V, A>
where
    A: Allocator<SplayTreeNode<K, V>>,
{
    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }
}

impl<K, V> SplayTree<K, V> {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            root: None,
            length: 0,
            allocator: ManuallyDrop::new(MemoryPool::with_capacity(capacity)),
        }
    }
}

impl<K, V, A> SplayTree<K, V, A>
where
    A: Allocator<SplayTreeNode<K, V>>,
{
    #[inline]
    fn splay<Seeker>(&mut self, seeker: Seeker) -> Option<Ordering>
    where
        Seeker: BstSeeker<Spec = SplayTreeSpec<K, V>>,
    {
        let (ordering, root) = splay_operations::splay(self.root.take()?, seeker);
        self.root = Some(root);
        Some(ordering)
    }

    fn splay_by_key<Q>(&mut self, key: &Q) -> Option<Ordering>
    where
        K: Borrow<Q>,
        Q: Ord + ?Sized,
    {
        self.splay(SeekByKey::new(key))
    }

    fn splay_by_size(&mut self, index: usize) -> Option<Ordering> {
        self.splay(SeekBySize::new(index))
    }

    pub fn get<Q>(&mut self, key: &Q) -> Option<&V>
    where
        K: Borrow<Q>,
        Q: Ord + ?Sized,
    {
        self.get_key_value(key).map(|(_, value)| value)
    }

    pub fn get_key_value<Q>(&mut self, key: &Q) -> Option<(&K, &V)>
    where
        K: Borrow<Q>,
        Q: Ord + ?Sized,
    {
        matches!(self.splay_by_key(key)?, Ordering::Equal).then(|| {
            let data = self.root.as_ref().unwrap().reborrow().into_data();
            (&data.key, &data.value)
        })
    }

    pub fn get_key_value_at(&mut self, index: usize) -> Option<(&K, &V)> {
        if index >= self.length {
            return None;
        }
        self.splay_by_size(index);
        let data = self.root.as_ref()?.reborrow().into_data();
        Some((&data.key, &data.value))
    }

crates/competitive/src/data_structure/implicit_splay_tree.rs (line 88)

    fn update_act(mut node: BstDataMutRef<'_, Self>, act: &T::Act) {
        if T::is_act_unit(act) {
            return;
        }
        T::act_operate_assign(&mut node.data_mut().value.act, act);
        node.data_mut().value.key = T::act_key(&node.reborrow().into_data().value.key, act);
        if let Some(agg) = T::act_agg(&node.reborrow().into_data().value.agg, act) {
            node.data_mut().value.agg = agg;
        } else {
            Self::top_down(node.reborrow_datamut());
            Self::bottom_up(node);
        }
    }

    fn reverse(mut node: BstDataMutRef<'_, Self>) {
        node.swap_children();
        let data = node.data_mut();
        T::toggle(&mut data.value.agg);
        data.rev ^= true;
    }
}

impl<T> BstSpec for ImplicitSplayTreeSpec<T>
where
    T: LazyMapMonoid,
{
    type Parent = WithNoParent<Self::Data>;
    type Data = ImplicitSplayTreeData<T>;

    fn top_down(mut node: BstDataMutRef<'_, Self>) {
        if !T::is_act_unit(&node.reborrow().into_data().value.act) {
            let act = replace(&mut node.data_mut().value.act, T::act_unit());
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::update_act(left, &act);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::update_act(right, &act);
            }
        }
        if node.reborrow().into_data().rev {
            node.data_mut().rev = false;
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::reverse(left);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::reverse(right);
            }
        }
    }

    fn bottom_up(mut node: BstDataMutRef<'_, Self>) {
        let mut agg = T::single_agg(&node.reborrow().into_data().value.key);
        let mut size = 1;
        if let Ok(left) = node.reborrow().left().descend() {
            let data = left.into_data();
            agg = T::agg_operate(&data.value.agg, &agg);
            size += data.size;
        }
        if let Ok(right) = node.reborrow().right().descend() {
            let data = right.into_data();
            agg = T::agg_operate(&agg, &data.value.agg);
            size += data.size;
        }
        let data = node.data_mut();
        data.value.agg = agg;
        data.size = size;
    }

    fn merge(
        left: Option<ImplicitSplayTreeRoot<T>>,
        right: Option<ImplicitSplayTreeRoot<T>>,
    ) -> Option<ImplicitSplayTreeRoot<T>> {
        splay_operations::merge(left, right)
    }

    fn split<Seeker>(
        node: Option<ImplicitSplayTreeRoot<T>>,
        seeker: Seeker,
        equal_side: EqualSide,
    ) -> (
        Option<ImplicitSplayTreeRoot<T>>,
        Option<ImplicitSplayTreeRoot<T>>,
    )
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        splay_operations::split(node, seeker, equal_side)
    }
}

pub struct ImplicitSplayTree<T, A = MemoryPool<ImplicitSplayTreeNode<T>>>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitSplayTreeNode<T>>,
{
    root: Option<ImplicitSplayTreeRoot<T>>,
    length: usize,
    allocator: ManuallyDrop<A>,
    _marker: PhantomData<fn() -> T>,
}

impl<T, A> Default for ImplicitSplayTree<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitSplayTreeNode<T>> + Default,
{
    fn default() -> Self {
        Self {
            root: None,
            length: 0,
            allocator: ManuallyDrop::new(A::default()),
            _marker: PhantomData,
        }
    }
}

impl<T, A> Drop for ImplicitSplayTree<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitSplayTreeNode<T>>,
{
    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }
}

impl<T> ImplicitSplayTree<T>
where
    T: LazyMapMonoid,
{
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            root: None,
            length: 0,
            allocator: ManuallyDrop::new(MemoryPool::with_capacity(capacity)),
            _marker: PhantomData,
        }
    }
}

impl<T, A> ImplicitSplayTree<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitSplayTreeNode<T>>,
{
    fn node(&mut self, key: T::Key) -> ImplicitSplayTreeRoot<T> {
        BstRoot::from_data(
            ImplicitSplayTreeData {
                value: LazyMapElement::from_key(key),
                size: 1,
                rev: false,
            },
            self.allocator.deref_mut(),
        )
    }

    #[inline]
    fn splay<Seeker>(&mut self, seeker: Seeker) -> Option<Ordering>
    where
        Seeker: BstSeeker<Spec = ImplicitSplayTreeSpec<T>>,
    {
        let (ordering, root) = splay_operations::splay(self.root.take()?, seeker);
        self.root = Some(root);
        Some(ordering)
    }

    pub fn len(&self) -> usize {
        self.length
    }

    pub fn is_empty(&self) -> bool {
        self.length == 0
    }

    pub fn update<R>(&mut self, range: R, act: T::Act)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitSplayTreeSpec::update_act(root, &act);
        }
    }

    pub fn fold<R>(&mut self, range: R) -> T::Agg
    where
        R: RangeBounds<usize>,
    {
        let split = Split3::seek_by_size(&mut self.root, range);
        split
            .mid()
            .map(|node| node.into_data().value.agg.clone())
            .unwrap_or_else(T::agg_unit)
    }

    pub fn reverse<R>(&mut self, range: R)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitSplayTreeSpec::reverse(root);
        }
    }

    pub fn get(&mut self, index: usize) -> Option<&T::Key> {
        if index >= self.length {
            return None;
        }
        self.splay(SeekBySize::new(index));
        Some(&self.root.as_ref()?.reborrow().into_data().value.key)
    }

crates/competitive/src/data_structure/implicit_treap.rs (line 89)

    fn update_act(mut node: BstDataMutRef<'_, Self>, act: &T::Act) {
        if T::is_act_unit(act) {
            return;
        }
        T::act_operate_assign(&mut node.data_mut().value.act, act);
        node.data_mut().value.key = T::act_key(&node.reborrow().into_data().value.key, act);
        if let Some(agg) = T::act_agg(&node.reborrow().into_data().value.agg, act) {
            node.data_mut().value.agg = agg;
        } else {
            Self::top_down(node.reborrow_datamut());
            Self::bottom_up(node);
        }
    }

    fn reverse(mut node: BstDataMutRef<'_, Self>) {
        node.swap_children();
        let data = node.data_mut();
        T::toggle(&mut data.value.agg);
        data.rev ^= true;
    }
}

impl<T> BstSpec for ImplicitTreapSpec<T>
where
    T: LazyMapMonoid,
{
    type Parent = WithNoParent<Self::Data>;
    type Data = ImplicitTreapData<T>;

    fn top_down(mut node: BstDataMutRef<'_, Self>) {
        if !T::is_act_unit(&node.reborrow().into_data().value.act) {
            let act = replace(&mut node.data_mut().value.act, T::act_unit());
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::update_act(left, &act);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::update_act(right, &act);
            }
        }
        if node.reborrow().into_data().rev {
            node.data_mut().rev = false;
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::reverse(left);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::reverse(right);
            }
        }
    }

    fn bottom_up(mut node: BstDataMutRef<'_, Self>) {
        let mut agg = T::single_agg(&node.reborrow().into_data().value.key);
        let mut size = 1;
        if let Ok(left) = node.reborrow().left().descend() {
            let data = left.into_data();
            agg = T::agg_operate(&data.value.agg, &agg);
            size += data.size;
        }
        if let Ok(right) = node.reborrow().right().descend() {
            let data = right.into_data();
            agg = T::agg_operate(&agg, &data.value.agg);
            size += data.size;
        }
        let data = node.data_mut();
        data.value.agg = agg;
        data.size = size;
    }

    fn merge(
        left: Option<ImplicitTreapRoot<T>>,
        right: Option<ImplicitTreapRoot<T>>,
    ) -> Option<ImplicitTreapRoot<T>> {
        match (left, right) {
            (None, None) => None,
            (None, Some(node)) | (Some(node), None) => Some(node),
            (Some(mut left), Some(mut right)) => unsafe {
                if left.reborrow().into_data().priority > right.reborrow().into_data().priority {
                    Self::top_down(left.borrow_datamut());
                    let lr = left.borrow_mut().right().take();
                    let lr = Self::merge(lr, Some(right)).unwrap_unchecked();
                    left.borrow_mut().right().set(lr);
                    Self::bottom_up(left.borrow_datamut());
                    Some(left)
                } else {
                    Self::top_down(right.borrow_datamut());
                    let rl = right.borrow_mut().left().take();
                    let rl = Self::merge(Some(left), rl).unwrap_unchecked();
                    right.borrow_mut().left().set(rl);
                    Self::bottom_up(right.borrow_datamut());
                    Some(right)
                }
            },
        }
    }

    fn split<Seeker>(
        node: Option<ImplicitTreapRoot<T>>,
        mut seeker: Seeker,
        equal_side: EqualSide,
    ) -> (Option<ImplicitTreapRoot<T>>, Option<ImplicitTreapRoot<T>>)
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        match node {
            None => (None, None),
            Some(mut node) => {
                Self::top_down(node.borrow_datamut());
                if equal_side.goes_left(seeker.bst_seek(node.reborrow())) {
                    unsafe {
                        let right = node.borrow_mut().right().take();
                        let (l, r) = Self::split(right, seeker, equal_side);
                        if let Some(l) = l {
                            node.borrow_mut().right().set(l);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (Some(node), r)
                    }
                } else {
                    unsafe {
                        let left = node.borrow_mut().left().take();
                        let (l, r) = Self::split(left, seeker, equal_side);
                        if let Some(r) = r {
                            node.borrow_mut().left().set(r);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (l, Some(node))
                    }
                }
            }
        }
    }

crates/competitive/src/data_structure/binary_search_tree/data.rs (line 44)

    pub fn bottom_up<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::MonoidAgg, Value = Self>>,
    {
        let mut agg = node.reborrow().into_data().bst_data().agg.clone();
        if let Ok(left) = node.reborrow().left().descend() {
            agg = M::operate(&left.into_data().bst_data().agg, &agg);
        }
        if let Ok(right) = node.reborrow().right().descend() {
            agg = M::operate(&agg, &right.into_data().bst_data().agg);
        }
        node.data_mut().bst_data_mut().agg = agg;
    }
}

pub struct MonoidActElement<M>
where
    M: MonoidAct,
{
    pub key: M::Key,
    pub act: M::Act,
}

impl<M> Debug for MonoidActElement<M>
where
    M: MonoidAct<Key: Debug, Act: Debug>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("MonoidActElement")
            .field("key", &self.key)
            .field("act", &self.act)
            .finish()
    }
}

impl<M> MonoidActElement<M>
where
    M: MonoidAct,
{
    pub fn from_key(key: M::Key) -> Self {
        Self {
            key,
            act: M::unit(),
        }
    }

    pub fn update_act<Spec>(mut node: BstDataMutRef<'_, Spec>, act: &M::Act)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::MonoidAct, Value = Self>>,
    {
        M::operate_assign(&mut node.data_mut().bst_data_mut().act, act);
        M::act_assign(&mut node.data_mut().bst_data_mut().key, act);
    }

    pub fn top_down<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::MonoidAct, Value = Self>>,
    {
        let act = replace(&mut node.data_mut().bst_data_mut().act, M::unit());
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::update_act(left, &act);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::update_act(right, &act);
        }
    }
}

pub struct LazyMapElement<L>
where
    L: LazyMapMonoid,
{
    pub key: L::Key,
    pub agg: L::Agg,
    pub act: L::Act,
}

impl<L> Debug for LazyMapElement<L>
where
    L: LazyMapMonoid<Key: Debug, Agg: Debug, Act: Debug>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("LazyMapElement")
            .field("key", &self.key)
            .field("agg", &self.agg)
            .field("act", &self.act)
            .finish()
    }
}

impl<L> LazyMapElement<L>
where
    L: LazyMapMonoid,
{
    pub fn from_key(key: L::Key) -> Self {
        let agg = L::single_agg(&key);
        Self {
            key,
            agg,
            act: L::act_unit(),
        }
    }

    pub fn update_act<Spec>(mut node: BstDataMutRef<'_, Spec>, act: &L::Act)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        if L::is_act_unit(act) {
            return;
        }
        L::act_operate_assign(&mut node.data_mut().bst_data_mut().act, act);
        node.data_mut().bst_data_mut().key =
            L::act_key(&node.reborrow().into_data().bst_data().key, act);
        if let Some(nxlazy) = L::act_agg(&node.reborrow().into_data().bst_data().agg, act) {
            node.data_mut().bst_data_mut().agg = nxlazy;
        } else {
            Self::top_down(node.reborrow_datamut());
            Self::bottom_up(node.reborrow_datamut());
        }
    }

    pub fn top_down<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        if L::is_act_unit(&node.reborrow().into_data().bst_data().act) {
            return;
        }
        let act = replace(&mut node.data_mut().bst_data_mut().act, L::act_unit());
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::update_act(left, &act);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::update_act(right, &act);
        }
    }

    pub fn bottom_up<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        let mut agg = L::single_agg(&node.reborrow().into_data().bst_data().key);
        if let Ok(left) = node.reborrow().left().descend() {
            agg = L::agg_operate(&left.into_data().bst_data().agg, &agg);
        }
        if let Ok(right) = node.reborrow().right().descend() {
            agg = L::agg_operate(&agg, &right.into_data().bst_data().agg);
        }
        node.data_mut().bst_data_mut().agg = agg;
    }

Additional examples can be found in:

• crates/competitive/src/tree/link_cut_tree.rs
• crates/competitive/src/data_structure/treap.rs
• crates/competitive/src/tree/top_tree.rs
• crates/competitive/src/data_structure/binary_search_tree/node.rs
• crates/competitive/src/data_structure/splay_operations.rs

pub fn left(self) -> BstEdgeHandle<Self, Left>

Examples found in repository

crates/competitive/src/data_structure/binary_search_tree/seeker.rs (line 29)

    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        if node.reborrow().left().descend().is_ok() {
            Ordering::Greater
        } else {
            Ordering::Equal
        }
    }
}

pub struct SeekRight<Spec> {
    _marker: PhantomData<fn() -> Spec>,
}

impl<S> Default for SeekRight<S> {
    fn default() -> Self {
        Self {
            _marker: PhantomData,
        }
    }
}

impl<Spec> BstSeeker for SeekRight<Spec>
where
    Spec: BstSpec,
{
    type Spec = Spec;
    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        if node.reborrow().right().descend().is_ok() {
            Ordering::Less
        } else {
            Ordering::Equal
        }
    }
}

pub struct SeekByKey<'a, Spec, K, Q>
where
    Q: ?Sized,
{
    key: &'a Q,
    _marker: PhantomData<fn() -> (Spec, K)>,
}

impl<'a, Spec, K, Q> SeekByKey<'a, Spec, K, Q>
where
    Q: ?Sized,
{
    pub fn new(key: &'a Q) -> Self {
        Self {
            key,
            _marker: PhantomData,
        }
    }
}

impl<Spec, K, Q> BstSeeker for SeekByKey<'_, Spec, K, Q>
where
    Spec: BstSpec<Data: BstDataAccess<data::marker::Key, Value = K>>,
    K: Borrow<Q>,
    Q: Ord + ?Sized,
{
    type Spec = Spec;

    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        node.reborrow()
            .into_data()
            .bst_data()
            .borrow()
            .cmp(self.key)
    }
}

pub struct SeekBySize<Spec> {
    index: usize,
    _marker: PhantomData<fn() -> Spec>,
}

impl<Spec> SeekBySize<Spec> {
    pub fn new(index: usize) -> Self {
        Self {
            index,
            _marker: PhantomData,
        }
    }
}

impl<Spec> BstSeeker for SeekBySize<Spec>
where
    Spec: BstSpec<Data: BstDataAccess<data::marker::Size, Value = usize>>,
{
    type Spec = Spec;

    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        let lsize = node
            .reborrow()
            .left()
            .descend()
            .map(|l| *l.into_data().bst_data())
            .unwrap_or_default();
        let ord = lsize.cmp(&self.index);
        if matches!(ord, Ordering::Less) {
            self.index -= lsize + 1;
        }
        ord
    }
}

pub struct SeekByAccCond<Spec, L, F>
where
    L: LazyMapMonoid,
{
    acc: L::Agg,
    f: F,
    _marker: PhantomData<fn() -> (Spec, L)>,
}

impl<Spec, L, F> SeekByAccCond<Spec, L, F>
where
    L: LazyMapMonoid,
    F: FnMut(&L::Agg) -> bool,
{
    pub fn new(f: F) -> Self {
        Self {
            acc: L::agg_unit(),
            f,
            _marker: PhantomData,
        }
    }
}

impl<Spec, L, F> BstSeeker for SeekByAccCond<Spec, L, F>
where
    Spec: BstSpec<Data: BstDataAccess<data::marker::LazyMap, Value = LazyMapElement<L>>>,
    L: LazyMapMonoid,
    F: FnMut(&L::Agg) -> bool,
{
    type Spec = Spec;

    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        if let Ok(left) = node.reborrow().left().descend() {
            let left_agg = &left.into_data().bst_data().agg;
            let nagg = L::agg_operate(&self.acc, left_agg);
            if (self.f)(&nagg) {
                return Ordering::Greater;
            }
            let nagg = L::agg_operate(
                &nagg,
                &L::single_agg(&node.reborrow().into_data().bst_data().key),
            );
            if (self.f)(&nagg) {
                Ordering::Equal
            } else {
                self.acc = nagg;
                Ordering::Less
            }
        } else {
            let nagg = L::agg_operate(
                &self.acc,
                &L::single_agg(&node.reborrow().into_data().bst_data().key),
            );
            if (self.f)(&nagg) {
                Ordering::Equal
            } else {
                self.acc = nagg;
                Ordering::Less
            }
        }
    }

crates/competitive/src/data_structure/splay_tree.rs (line 81)

    fn bottom_up(mut node: BstDataMutRef<'_, Self>) {
        let left = node
            .reborrow()
            .left()
            .descend()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        let right = node
            .reborrow()
            .right()
            .descend()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        node.data_mut().size = left + right + 1;
    }

crates/competitive/src/data_structure/binary_search_tree/data.rs (line 45)

    pub fn bottom_up<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::MonoidAgg, Value = Self>>,
    {
        let mut agg = node.reborrow().into_data().bst_data().agg.clone();
        if let Ok(left) = node.reborrow().left().descend() {
            agg = M::operate(&left.into_data().bst_data().agg, &agg);
        }
        if let Ok(right) = node.reborrow().right().descend() {
            agg = M::operate(&agg, &right.into_data().bst_data().agg);
        }
        node.data_mut().bst_data_mut().agg = agg;
    }
}

pub struct MonoidActElement<M>
where
    M: MonoidAct,
{
    pub key: M::Key,
    pub act: M::Act,
}

impl<M> Debug for MonoidActElement<M>
where
    M: MonoidAct<Key: Debug, Act: Debug>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("MonoidActElement")
            .field("key", &self.key)
            .field("act", &self.act)
            .finish()
    }
}

impl<M> MonoidActElement<M>
where
    M: MonoidAct,
{
    pub fn from_key(key: M::Key) -> Self {
        Self {
            key,
            act: M::unit(),
        }
    }

    pub fn update_act<Spec>(mut node: BstDataMutRef<'_, Spec>, act: &M::Act)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::MonoidAct, Value = Self>>,
    {
        M::operate_assign(&mut node.data_mut().bst_data_mut().act, act);
        M::act_assign(&mut node.data_mut().bst_data_mut().key, act);
    }

    pub fn top_down<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::MonoidAct, Value = Self>>,
    {
        let act = replace(&mut node.data_mut().bst_data_mut().act, M::unit());
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::update_act(left, &act);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::update_act(right, &act);
        }
    }
}

pub struct LazyMapElement<L>
where
    L: LazyMapMonoid,
{
    pub key: L::Key,
    pub agg: L::Agg,
    pub act: L::Act,
}

impl<L> Debug for LazyMapElement<L>
where
    L: LazyMapMonoid<Key: Debug, Agg: Debug, Act: Debug>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("LazyMapElement")
            .field("key", &self.key)
            .field("agg", &self.agg)
            .field("act", &self.act)
            .finish()
    }
}

impl<L> LazyMapElement<L>
where
    L: LazyMapMonoid,
{
    pub fn from_key(key: L::Key) -> Self {
        let agg = L::single_agg(&key);
        Self {
            key,
            agg,
            act: L::act_unit(),
        }
    }

    pub fn update_act<Spec>(mut node: BstDataMutRef<'_, Spec>, act: &L::Act)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        if L::is_act_unit(act) {
            return;
        }
        L::act_operate_assign(&mut node.data_mut().bst_data_mut().act, act);
        node.data_mut().bst_data_mut().key =
            L::act_key(&node.reborrow().into_data().bst_data().key, act);
        if let Some(nxlazy) = L::act_agg(&node.reborrow().into_data().bst_data().agg, act) {
            node.data_mut().bst_data_mut().agg = nxlazy;
        } else {
            Self::top_down(node.reborrow_datamut());
            Self::bottom_up(node.reborrow_datamut());
        }
    }

    pub fn top_down<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        if L::is_act_unit(&node.reborrow().into_data().bst_data().act) {
            return;
        }
        let act = replace(&mut node.data_mut().bst_data_mut().act, L::act_unit());
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::update_act(left, &act);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::update_act(right, &act);
        }
    }

    pub fn bottom_up<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        let mut agg = L::single_agg(&node.reborrow().into_data().bst_data().key);
        if let Ok(left) = node.reborrow().left().descend() {
            agg = L::agg_operate(&left.into_data().bst_data().agg, &agg);
        }
        if let Ok(right) = node.reborrow().right().descend() {
            agg = L::agg_operate(&agg, &right.into_data().bst_data().agg);
        }
        node.data_mut().bst_data_mut().agg = agg;
    }

crates/competitive/src/data_structure/binary_search_tree/node.rs (line 148)

    pub fn resolve_top_down<Spec>(node: BstNodeRef<marker::DataMut<'_>, Spec>)
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        unsafe {
            let (mut node, mut stack) = node.root_path();
            while let Some(is_left) = stack.pop() {
                Spec::top_down(node.reborrow_datamut());
                if is_left {
                    node = node.left().descend().unwrap_unchecked();
                } else {
                    node = node.right().descend().unwrap_unchecked();
                }
            }
            Spec::top_down(node.reborrow_datamut());
        }
    }

    pub fn resolve_bottom_up<Spec>(mut node: BstNodeRef<marker::DataMut<'_>, Spec>)
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        loop {
            Spec::bottom_up(node.reborrow_datamut());
            match node.ascend() {
                Ok(parent) => node = parent,
                Err(_) => break,
            }
        }
    }

    pub fn is_root<Spec>(node: BstNodeRef<marker::Immut<'_>, Spec>) -> bool
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        unsafe { node.node.as_ref().parent.parent.is_none() }
    }

    pub unsafe fn remove_root<Spec>(
        root: &mut Option<BstRoot<Spec>>,
    ) -> Option<BstNodeRef<marker::Owned, Spec>>
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        let mut node = root.take()?;
        unsafe {
            let left = node.borrow_mut().left_mut().take();
            let right = node.borrow_mut().right_mut().take();
            *root = Spec::merge(left, right);
            Spec::bottom_up(node.borrow_datamut());
            Some(node)
        }
    }

    pub unsafe fn remove_not_root<Spec>(
        mut node: BstNodeRef<marker::Mut<'_>, Spec>,
    ) -> BstNodeRef<marker::Owned, Spec>
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        assert!(!Self::is_root(node.reborrow()));
        unsafe {
            let left = node.left_mut().take();
            let right = node.right_mut().take();
            let merged = Spec::merge(left, right);
            let node_inner = node.node;
            let mut parent = node.ascend().unwrap_unchecked();
            let mut node = if let Some(merged) = merged {
                let node = if parent
                    .reborrow()
                    .left()
                    .descend()
                    .is_ok_and(|n| n.node == node_inner)
                {
                    parent.left_mut().replace(merged)
                } else {
                    parent.right_mut().replace(merged)
                };
                Self::resolve_bottom_up(parent.reborrow_datamut());
                node.unwrap_unchecked()
            } else {
                let node = if parent
                    .reborrow()
                    .left()
                    .descend()
                    .is_ok_and(|n| n.node == node_inner)
                {
                    parent.left_mut().take()
                } else {
                    parent.right_mut().take()
                };
                Self::resolve_bottom_up(parent.reborrow_datamut());
                node.unwrap_unchecked()
            };
            Spec::bottom_up(node.borrow_datamut());
            node
        }
    }
}

pub struct BstNodeRef<BorrowType, Spec>
where
    Spec: BstSpec,
{
    pub node: NonNull<BstNode<Spec::Data, Spec::Parent>>,
    _marker: PhantomData<BorrowType>,
}

impl<'a, Spec> Copy for BstNodeRef<marker::Immut<'a>, Spec> where Spec: BstSpec<Data: 'a> {}
impl<'a, Spec> Clone for BstNodeRef<marker::Immut<'a>, Spec>
where
    Spec: BstSpec<Data: 'a>,
{
    fn clone(&self) -> Self {
        *self
    }
}

impl<BorrowType, Spec> BstNodeRef<BorrowType, Spec>
where
    Spec: BstSpec,
    BorrowType: marker::BorrowType,
{
    pub unsafe fn new_unchecked(node: NonNull<BstNode<Spec::Data, Spec::Parent>>) -> Self {
        Self {
            node,
            _marker: PhantomData,
        }
    }
    pub fn reborrow(&self) -> BstNodeRef<marker::Immut<'_>, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
    pub fn left(self) -> BstEdgeHandle<Self, marker::Left> {
        BstEdgeHandle {
            node: self,
            _marker: PhantomData,
        }
    }
    pub fn right(self) -> BstEdgeHandle<Self, marker::Right> {
        BstEdgeHandle {
            node: self,
            _marker: PhantomData,
        }
    }
}

impl<BorrowType, Spec, Data> BstNodeRef<BorrowType, Spec>
where
    Spec: BstSpec<Data = Data, Parent = WithParent<Data>>,
    BorrowType: marker::BorrowType,
{
    pub fn ascend(self) -> Result<BstNodeRef<BorrowType, Spec>, Self> {
        const {
            assert!(BorrowType::TRAVERSAL_PERMIT);
        };
        let parent = unsafe { self.node.as_ref().parent.parent };
        parent
            .map(|node| BstNodeRef {
                node,
                _marker: PhantomData,
            })
            .ok_or(self)
    }
    pub fn root_path(self) -> (Self, Vec<bool>) {
        let mut node = self;
        let mut nn = node.node;
        let mut stack = vec![];
        let root = loop {
            match node.ascend() {
                Ok(parent) => {
                    node = parent;
                    stack.push(
                        node.reborrow()
                            .left()
                            .descend()
                            .is_ok_and(|node| node.node == nn),
                    );
                    nn = node.node;
                }
                Err(node) => {
                    break node;
                }
            }
        };
        (root, stack)
    }
}

impl<Spec> BstNodeRef<marker::Owned, Spec>
where
    Spec: BstSpec,
{
    pub fn new(node: NonNull<BstNode<Spec::Data, Spec::Parent>>) -> Self {
        Self {
            node,
            _marker: PhantomData,
        }
    }
    pub fn from_data<A>(data: Spec::Data, allocator: &mut A) -> Self
    where
        A: Allocator<BstNode<Spec::Data, Spec::Parent>>,
    {
        Self::new(allocator.allocate(BstNode::new(data)))
    }
    pub fn borrow_mut(&mut self) -> BstNodeRef<marker::Mut<'_>, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
    pub fn borrow_datamut(&mut self) -> BstNodeRef<marker::DataMut<'_>, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
    pub fn into_dying(self) -> BstNodeRef<marker::Dying, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
}

impl<'a, Spec> BstNodeRef<marker::Immut<'a>, Spec>
where
    Spec: BstSpec<Parent: 'a, Data: 'a>,
{
    pub fn into_data(self) -> &'a Spec::Data {
        unsafe { &self.node.as_ref().data }
    }

    pub fn traverse<F>(self, f: &mut F)
    where
        F: FnMut(Self),
    {
        if let Ok(left) = self.left().descend() {
            left.traverse(f);
        }
        f(self);
        if let Ok(right) = self.right().descend() {
            right.traverse(f);
        }
    }

    pub fn leftmost(self) -> Self {
        let mut node = self;
        while let Ok(left) = node.left().descend() {
            node = left;
        }
        node
    }

    pub fn rightmost(self) -> Self {
        let mut node = self;
        while let Ok(right) = node.right().descend() {
            node = right;
        }
        node
    }
}

impl<'a, Spec> BstNodeRef<marker::DataMut<'a>, Spec>
where
    Spec: BstSpec,
{
    pub fn reborrow_datamut(&mut self) -> BstNodeRef<marker::DataMut<'_>, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
    pub fn data_mut(&mut self) -> &mut Spec::Data {
        unsafe { &mut self.node.as_mut().data }
    }

    pub fn swap_children(&mut self) {
        unsafe { self.node.as_mut().child.swap(0, 1) };
    }
}

impl<'a, Spec> BstNodeRef<marker::DataMut<'a>, Spec>
where
    Spec: BstSpec<Parent: 'a, Data: 'a>,
{
    pub fn into_data_mut(mut self) -> &'a mut Spec::Data {
        unsafe { &mut self.node.as_mut().data }
    }
}

impl<'a, Spec> BstNodeRef<marker::Mut<'a>, Spec>
where
    Spec: BstSpec,
{
    pub fn reborrow_datamut(&mut self) -> BstNodeRef<marker::DataMut<'_>, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }

    pub fn left_mut(&mut self) -> BstEdgeHandle<BstNodeRef<marker::Mut<'_>, Spec>, marker::Left> {
        BstEdgeHandle {
            node: BstNodeRef {
                node: self.node,
                _marker: PhantomData,
            },
            _marker: PhantomData,
        }
    }

    pub fn right_mut(&mut self) -> BstEdgeHandle<BstNodeRef<marker::Mut<'_>, Spec>, marker::Right> {
        BstEdgeHandle {
            node: BstNodeRef {
                node: self.node,
                _marker: PhantomData,
            },
            _marker: PhantomData,
        }
    }
}

impl<'a, Spec> BstNodeRef<marker::Mut<'a>, Spec>
where
    Spec: BstSpec<Data: 'a>,
{
    pub fn dormant(self) -> BstNodeRef<marker::DormantMut, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
}

impl<Spec> BstNodeRef<marker::DormantMut, Spec>
where
    Spec: BstSpec,
{
    pub unsafe fn awaken<'a>(self) -> BstNodeRef<marker::Mut<'a>, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
}

impl<Spec> BstNodeRef<marker::Dying, Spec>
where
    Spec: BstSpec,
{
    pub unsafe fn into_data<A>(self, allocator: &mut A) -> Spec::Data
    where
        A: Allocator<BstNode<Spec::Data, Spec::Parent>>,
    {
        debug_assert!(self.reborrow().left().descend().is_err());
        debug_assert!(self.reborrow().right().descend().is_err());
        allocator.deallocate(self.node).data
    }

crates/competitive/src/data_structure/implicit_splay_tree.rs (line 115)

    fn top_down(mut node: BstDataMutRef<'_, Self>) {
        if !T::is_act_unit(&node.reborrow().into_data().value.act) {
            let act = replace(&mut node.data_mut().value.act, T::act_unit());
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::update_act(left, &act);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::update_act(right, &act);
            }
        }
        if node.reborrow().into_data().rev {
            node.data_mut().rev = false;
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::reverse(left);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::reverse(right);
            }
        }
    }

    fn bottom_up(mut node: BstDataMutRef<'_, Self>) {
        let mut agg = T::single_agg(&node.reborrow().into_data().value.key);
        let mut size = 1;
        if let Ok(left) = node.reborrow().left().descend() {
            let data = left.into_data();
            agg = T::agg_operate(&data.value.agg, &agg);
            size += data.size;
        }
        if let Ok(right) = node.reborrow().right().descend() {
            let data = right.into_data();
            agg = T::agg_operate(&agg, &data.value.agg);
            size += data.size;
        }
        let data = node.data_mut();
        data.value.agg = agg;
        data.size = size;
    }

crates/competitive/src/data_structure/implicit_treap.rs (line 116)

    fn top_down(mut node: BstDataMutRef<'_, Self>) {
        if !T::is_act_unit(&node.reborrow().into_data().value.act) {
            let act = replace(&mut node.data_mut().value.act, T::act_unit());
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::update_act(left, &act);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::update_act(right, &act);
            }
        }
        if node.reborrow().into_data().rev {
            node.data_mut().rev = false;
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::reverse(left);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::reverse(right);
            }
        }
    }

    fn bottom_up(mut node: BstDataMutRef<'_, Self>) {
        let mut agg = T::single_agg(&node.reborrow().into_data().value.key);
        let mut size = 1;
        if let Ok(left) = node.reborrow().left().descend() {
            let data = left.into_data();
            agg = T::agg_operate(&data.value.agg, &agg);
            size += data.size;
        }
        if let Ok(right) = node.reborrow().right().descend() {
            let data = right.into_data();
            agg = T::agg_operate(&agg, &data.value.agg);
            size += data.size;
        }
        let data = node.data_mut();
        data.value.agg = agg;
        data.size = size;
    }

    fn merge(
        left: Option<ImplicitTreapRoot<T>>,
        right: Option<ImplicitTreapRoot<T>>,
    ) -> Option<ImplicitTreapRoot<T>> {
        match (left, right) {
            (None, None) => None,
            (None, Some(node)) | (Some(node), None) => Some(node),
            (Some(mut left), Some(mut right)) => unsafe {
                if left.reborrow().into_data().priority > right.reborrow().into_data().priority {
                    Self::top_down(left.borrow_datamut());
                    let lr = left.borrow_mut().right().take();
                    let lr = Self::merge(lr, Some(right)).unwrap_unchecked();
                    left.borrow_mut().right().set(lr);
                    Self::bottom_up(left.borrow_datamut());
                    Some(left)
                } else {
                    Self::top_down(right.borrow_datamut());
                    let rl = right.borrow_mut().left().take();
                    let rl = Self::merge(Some(left), rl).unwrap_unchecked();
                    right.borrow_mut().left().set(rl);
                    Self::bottom_up(right.borrow_datamut());
                    Some(right)
                }
            },
        }
    }

    fn split<Seeker>(
        node: Option<ImplicitTreapRoot<T>>,
        mut seeker: Seeker,
        equal_side: EqualSide,
    ) -> (Option<ImplicitTreapRoot<T>>, Option<ImplicitTreapRoot<T>>)
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        match node {
            None => (None, None),
            Some(mut node) => {
                Self::top_down(node.borrow_datamut());
                if equal_side.goes_left(seeker.bst_seek(node.reborrow())) {
                    unsafe {
                        let right = node.borrow_mut().right().take();
                        let (l, r) = Self::split(right, seeker, equal_side);
                        if let Some(l) = l {
                            node.borrow_mut().right().set(l);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (Some(node), r)
                    }
                } else {
                    unsafe {
                        let left = node.borrow_mut().left().take();
                        let (l, r) = Self::split(left, seeker, equal_side);
                        if let Some(r) = r {
                            node.borrow_mut().left().set(r);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (l, Some(node))
                    }
                }
            }
        }
    }
}

pub struct ImplicitTreap<T, A = MemoryPool<ImplicitTreapNode<T>>>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>>,
{
    root: Option<ImplicitTreapRoot<T>>,
    length: usize,
    rng: Xorshift,
    allocator: ManuallyDrop<A>,
    _marker: PhantomData<fn() -> T>,
}

impl<T, A> Default for ImplicitTreap<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>> + Default,
{
    fn default() -> Self {
        Self {
            root: None,
            length: 0,
            rng: Xorshift::new(),
            allocator: ManuallyDrop::new(A::default()),
            _marker: PhantomData,
        }
    }
}

impl<T, A> Drop for ImplicitTreap<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>>,
{
    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }
}

impl<T> ImplicitTreap<T>
where
    T: LazyMapMonoid,
{
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            root: None,
            length: 0,
            rng: Xorshift::new(),
            allocator: ManuallyDrop::new(MemoryPool::with_capacity(capacity)),
            _marker: PhantomData,
        }
    }
}

impl<T, A> ImplicitTreap<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>>,
{
    fn node(&mut self, key: T::Key) -> ImplicitTreapRoot<T> {
        BstRoot::from_data(
            ImplicitTreapData {
                priority: self.rng.rand64(),
                value: LazyMapElement::from_key(key),
                size: 1,
                rev: false,
            },
            self.allocator.deref_mut(),
        )
    }

    fn build<I>(&mut self, iter: I) -> (Option<ImplicitTreapRoot<T>>, usize)
    where
        I: IntoIterator<Item = T::Key>,
    {
        let mut stack = vec![];
        let mut len = 0;
        for key in iter {
            let mut cur = self.node(key).node;
            let mut left = None;
            unsafe {
                while stack
                    .last()
                    .is_some_and(|node: &NonNull<ImplicitTreapNode<T>>| {
                        node.as_ref().data.priority < cur.as_ref().data.priority
                    })
                {
                    left = stack.pop();
                }
                cur.as_mut().child[0] = left;
                if let Some(parent) = stack.last_mut() {
                    parent.as_mut().child[1] = Some(cur);
                }
            }
            stack.push(cur);
            len += 1;
        }
        let root = stack.first().copied().map(BstRoot::new);
        if let Some(mut root) = root {
            Self::build_bottom_up(root.borrow_datamut());
            (Some(root), len)
        } else {
            (None, len)
        }
    }

    fn build_bottom_up(mut node: BstDataMutRef<'_, ImplicitTreapSpec<T>>) {
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::build_bottom_up(left);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::build_bottom_up(right);
        }
        ImplicitTreapSpec::<T>::bottom_up(node);
    }

Additional examples can be found in:

• crates/competitive/src/data_structure/splay_operations.rs
• crates/competitive/src/data_structure/treap.rs

pub fn right(self) -> BstEdgeHandle<Self, Right>

Examples found in repository

crates/competitive/src/data_structure/binary_search_tree/seeker.rs (line 55)

    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        if node.reborrow().right().descend().is_ok() {
            Ordering::Less
        } else {
            Ordering::Equal
        }
    }
}

pub struct SeekByKey<'a, Spec, K, Q>
where
    Q: ?Sized,
{
    key: &'a Q,
    _marker: PhantomData<fn() -> (Spec, K)>,
}

impl<'a, Spec, K, Q> SeekByKey<'a, Spec, K, Q>
where
    Q: ?Sized,
{
    pub fn new(key: &'a Q) -> Self {
        Self {
            key,
            _marker: PhantomData,
        }
    }
}

impl<Spec, K, Q> BstSeeker for SeekByKey<'_, Spec, K, Q>
where
    Spec: BstSpec<Data: BstDataAccess<data::marker::Key, Value = K>>,
    K: Borrow<Q>,
    Q: Ord + ?Sized,
{
    type Spec = Spec;

    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        node.reborrow()
            .into_data()
            .bst_data()
            .borrow()
            .cmp(self.key)
    }
}

pub struct SeekBySize<Spec> {
    index: usize,
    _marker: PhantomData<fn() -> Spec>,
}

impl<Spec> SeekBySize<Spec> {
    pub fn new(index: usize) -> Self {
        Self {
            index,
            _marker: PhantomData,
        }
    }
}

impl<Spec> BstSeeker for SeekBySize<Spec>
where
    Spec: BstSpec<Data: BstDataAccess<data::marker::Size, Value = usize>>,
{
    type Spec = Spec;

    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        let lsize = node
            .reborrow()
            .left()
            .descend()
            .map(|l| *l.into_data().bst_data())
            .unwrap_or_default();
        let ord = lsize.cmp(&self.index);
        if matches!(ord, Ordering::Less) {
            self.index -= lsize + 1;
        }
        ord
    }
}

pub struct SeekByAccCond<Spec, L, F>
where
    L: LazyMapMonoid,
{
    acc: L::Agg,
    f: F,
    _marker: PhantomData<fn() -> (Spec, L)>,
}

impl<Spec, L, F> SeekByAccCond<Spec, L, F>
where
    L: LazyMapMonoid,
    F: FnMut(&L::Agg) -> bool,
{
    pub fn new(f: F) -> Self {
        Self {
            acc: L::agg_unit(),
            f,
            _marker: PhantomData,
        }
    }
}

impl<Spec, L, F> BstSeeker for SeekByAccCond<Spec, L, F>
where
    Spec: BstSpec<Data: BstDataAccess<data::marker::LazyMap, Value = LazyMapElement<L>>>,
    L: LazyMapMonoid,
    F: FnMut(&L::Agg) -> bool,
{
    type Spec = Spec;

    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        if let Ok(left) = node.reborrow().left().descend() {
            let left_agg = &left.into_data().bst_data().agg;
            let nagg = L::agg_operate(&self.acc, left_agg);
            if (self.f)(&nagg) {
                return Ordering::Greater;
            }
            let nagg = L::agg_operate(
                &nagg,
                &L::single_agg(&node.reborrow().into_data().bst_data().key),
            );
            if (self.f)(&nagg) {
                Ordering::Equal
            } else {
                self.acc = nagg;
                Ordering::Less
            }
        } else {
            let nagg = L::agg_operate(
                &self.acc,
                &L::single_agg(&node.reborrow().into_data().bst_data().key),
            );
            if (self.f)(&nagg) {
                Ordering::Equal
            } else {
                self.acc = nagg;
                Ordering::Less
            }
        }
    }
}

pub struct SeekByRaccCond<Spec, L, F>
where
    L: LazyMapMonoid,
{
    acc: L::Agg,
    f: F,
    _marker: PhantomData<fn() -> (Spec, L)>,
}

impl<Spec, L, F> SeekByRaccCond<Spec, L, F>
where
    L: LazyMapMonoid,
    F: FnMut(&L::Agg) -> bool,
{
    pub fn new(f: F) -> Self {
        Self {
            acc: L::agg_unit(),
            f,
            _marker: PhantomData,
        }
    }
}

impl<Spec, L, F> BstSeeker for SeekByRaccCond<Spec, L, F>
where
    Spec: BstSpec<Data: BstDataAccess<data::marker::LazyMap, Value = LazyMapElement<L>>>,
    L: LazyMapMonoid,
    F: FnMut(&L::Agg) -> bool,
{
    type Spec = Spec;

    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        if let Ok(right) = node.reborrow().right().descend() {
            let right_agg = &right.into_data().bst_data().agg;
            let nagg = L::agg_operate(right_agg, &self.acc);
            if (self.f)(&nagg) {
                return Ordering::Less;
            }
            let nagg = L::agg_operate(
                &L::single_agg(&node.reborrow().into_data().bst_data().key),
                &nagg,
            );
            if (self.f)(&nagg) {
                Ordering::Equal
            } else {
                self.acc = nagg;
                Ordering::Greater
            }
        } else {
            let nagg = L::agg_operate(
                &L::single_agg(&node.reborrow().into_data().bst_data().key),
                &self.acc,
            );
            if (self.f)(&nagg) {
                Ordering::Equal
            } else {
                self.acc = nagg;
                Ordering::Greater
            }
        }
    }

crates/competitive/src/data_structure/splay_tree.rs (line 87)

    fn bottom_up(mut node: BstDataMutRef<'_, Self>) {
        let left = node
            .reborrow()
            .left()
            .descend()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        let right = node
            .reborrow()
            .right()
            .descend()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        node.data_mut().size = left + right + 1;
    }

crates/competitive/src/data_structure/binary_search_tree/data.rs (line 48)

    pub fn bottom_up<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::MonoidAgg, Value = Self>>,
    {
        let mut agg = node.reborrow().into_data().bst_data().agg.clone();
        if let Ok(left) = node.reborrow().left().descend() {
            agg = M::operate(&left.into_data().bst_data().agg, &agg);
        }
        if let Ok(right) = node.reborrow().right().descend() {
            agg = M::operate(&agg, &right.into_data().bst_data().agg);
        }
        node.data_mut().bst_data_mut().agg = agg;
    }
}

pub struct MonoidActElement<M>
where
    M: MonoidAct,
{
    pub key: M::Key,
    pub act: M::Act,
}

impl<M> Debug for MonoidActElement<M>
where
    M: MonoidAct<Key: Debug, Act: Debug>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("MonoidActElement")
            .field("key", &self.key)
            .field("act", &self.act)
            .finish()
    }
}

impl<M> MonoidActElement<M>
where
    M: MonoidAct,
{
    pub fn from_key(key: M::Key) -> Self {
        Self {
            key,
            act: M::unit(),
        }
    }

    pub fn update_act<Spec>(mut node: BstDataMutRef<'_, Spec>, act: &M::Act)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::MonoidAct, Value = Self>>,
    {
        M::operate_assign(&mut node.data_mut().bst_data_mut().act, act);
        M::act_assign(&mut node.data_mut().bst_data_mut().key, act);
    }

    pub fn top_down<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::MonoidAct, Value = Self>>,
    {
        let act = replace(&mut node.data_mut().bst_data_mut().act, M::unit());
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::update_act(left, &act);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::update_act(right, &act);
        }
    }
}

pub struct LazyMapElement<L>
where
    L: LazyMapMonoid,
{
    pub key: L::Key,
    pub agg: L::Agg,
    pub act: L::Act,
}

impl<L> Debug for LazyMapElement<L>
where
    L: LazyMapMonoid<Key: Debug, Agg: Debug, Act: Debug>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("LazyMapElement")
            .field("key", &self.key)
            .field("agg", &self.agg)
            .field("act", &self.act)
            .finish()
    }
}

impl<L> LazyMapElement<L>
where
    L: LazyMapMonoid,
{
    pub fn from_key(key: L::Key) -> Self {
        let agg = L::single_agg(&key);
        Self {
            key,
            agg,
            act: L::act_unit(),
        }
    }

    pub fn update_act<Spec>(mut node: BstDataMutRef<'_, Spec>, act: &L::Act)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        if L::is_act_unit(act) {
            return;
        }
        L::act_operate_assign(&mut node.data_mut().bst_data_mut().act, act);
        node.data_mut().bst_data_mut().key =
            L::act_key(&node.reborrow().into_data().bst_data().key, act);
        if let Some(nxlazy) = L::act_agg(&node.reborrow().into_data().bst_data().agg, act) {
            node.data_mut().bst_data_mut().agg = nxlazy;
        } else {
            Self::top_down(node.reborrow_datamut());
            Self::bottom_up(node.reborrow_datamut());
        }
    }

    pub fn top_down<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        if L::is_act_unit(&node.reborrow().into_data().bst_data().act) {
            return;
        }
        let act = replace(&mut node.data_mut().bst_data_mut().act, L::act_unit());
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::update_act(left, &act);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::update_act(right, &act);
        }
    }

    pub fn bottom_up<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        let mut agg = L::single_agg(&node.reborrow().into_data().bst_data().key);
        if let Ok(left) = node.reborrow().left().descend() {
            agg = L::agg_operate(&left.into_data().bst_data().agg, &agg);
        }
        if let Ok(right) = node.reborrow().right().descend() {
            agg = L::agg_operate(&agg, &right.into_data().bst_data().agg);
        }
        node.data_mut().bst_data_mut().agg = agg;
    }

crates/competitive/src/data_structure/binary_search_tree/node.rs (line 150)

    pub fn resolve_top_down<Spec>(node: BstNodeRef<marker::DataMut<'_>, Spec>)
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        unsafe {
            let (mut node, mut stack) = node.root_path();
            while let Some(is_left) = stack.pop() {
                Spec::top_down(node.reborrow_datamut());
                if is_left {
                    node = node.left().descend().unwrap_unchecked();
                } else {
                    node = node.right().descend().unwrap_unchecked();
                }
            }
            Spec::top_down(node.reborrow_datamut());
        }
    }

    pub fn resolve_bottom_up<Spec>(mut node: BstNodeRef<marker::DataMut<'_>, Spec>)
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        loop {
            Spec::bottom_up(node.reborrow_datamut());
            match node.ascend() {
                Ok(parent) => node = parent,
                Err(_) => break,
            }
        }
    }

    pub fn is_root<Spec>(node: BstNodeRef<marker::Immut<'_>, Spec>) -> bool
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        unsafe { node.node.as_ref().parent.parent.is_none() }
    }

    pub unsafe fn remove_root<Spec>(
        root: &mut Option<BstRoot<Spec>>,
    ) -> Option<BstNodeRef<marker::Owned, Spec>>
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        let mut node = root.take()?;
        unsafe {
            let left = node.borrow_mut().left_mut().take();
            let right = node.borrow_mut().right_mut().take();
            *root = Spec::merge(left, right);
            Spec::bottom_up(node.borrow_datamut());
            Some(node)
        }
    }

    pub unsafe fn remove_not_root<Spec>(
        mut node: BstNodeRef<marker::Mut<'_>, Spec>,
    ) -> BstNodeRef<marker::Owned, Spec>
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        assert!(!Self::is_root(node.reborrow()));
        unsafe {
            let left = node.left_mut().take();
            let right = node.right_mut().take();
            let merged = Spec::merge(left, right);
            let node_inner = node.node;
            let mut parent = node.ascend().unwrap_unchecked();
            let mut node = if let Some(merged) = merged {
                let node = if parent
                    .reborrow()
                    .left()
                    .descend()
                    .is_ok_and(|n| n.node == node_inner)
                {
                    parent.left_mut().replace(merged)
                } else {
                    parent.right_mut().replace(merged)
                };
                Self::resolve_bottom_up(parent.reborrow_datamut());
                node.unwrap_unchecked()
            } else {
                let node = if parent
                    .reborrow()
                    .left()
                    .descend()
                    .is_ok_and(|n| n.node == node_inner)
                {
                    parent.left_mut().take()
                } else {
                    parent.right_mut().take()
                };
                Self::resolve_bottom_up(parent.reborrow_datamut());
                node.unwrap_unchecked()
            };
            Spec::bottom_up(node.borrow_datamut());
            node
        }
    }
}

pub struct BstNodeRef<BorrowType, Spec>
where
    Spec: BstSpec,
{
    pub node: NonNull<BstNode<Spec::Data, Spec::Parent>>,
    _marker: PhantomData<BorrowType>,
}

impl<'a, Spec> Copy for BstNodeRef<marker::Immut<'a>, Spec> where Spec: BstSpec<Data: 'a> {}
impl<'a, Spec> Clone for BstNodeRef<marker::Immut<'a>, Spec>
where
    Spec: BstSpec<Data: 'a>,
{
    fn clone(&self) -> Self {
        *self
    }
}

impl<BorrowType, Spec> BstNodeRef<BorrowType, Spec>
where
    Spec: BstSpec,
    BorrowType: marker::BorrowType,
{
    pub unsafe fn new_unchecked(node: NonNull<BstNode<Spec::Data, Spec::Parent>>) -> Self {
        Self {
            node,
            _marker: PhantomData,
        }
    }
    pub fn reborrow(&self) -> BstNodeRef<marker::Immut<'_>, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
    pub fn left(self) -> BstEdgeHandle<Self, marker::Left> {
        BstEdgeHandle {
            node: self,
            _marker: PhantomData,
        }
    }
    pub fn right(self) -> BstEdgeHandle<Self, marker::Right> {
        BstEdgeHandle {
            node: self,
            _marker: PhantomData,
        }
    }
}

impl<BorrowType, Spec, Data> BstNodeRef<BorrowType, Spec>
where
    Spec: BstSpec<Data = Data, Parent = WithParent<Data>>,
    BorrowType: marker::BorrowType,
{
    pub fn ascend(self) -> Result<BstNodeRef<BorrowType, Spec>, Self> {
        const {
            assert!(BorrowType::TRAVERSAL_PERMIT);
        };
        let parent = unsafe { self.node.as_ref().parent.parent };
        parent
            .map(|node| BstNodeRef {
                node,
                _marker: PhantomData,
            })
            .ok_or(self)
    }
    pub fn root_path(self) -> (Self, Vec<bool>) {
        let mut node = self;
        let mut nn = node.node;
        let mut stack = vec![];
        let root = loop {
            match node.ascend() {
                Ok(parent) => {
                    node = parent;
                    stack.push(
                        node.reborrow()
                            .left()
                            .descend()
                            .is_ok_and(|node| node.node == nn),
                    );
                    nn = node.node;
                }
                Err(node) => {
                    break node;
                }
            }
        };
        (root, stack)
    }
}

impl<Spec> BstNodeRef<marker::Owned, Spec>
where
    Spec: BstSpec,
{
    pub fn new(node: NonNull<BstNode<Spec::Data, Spec::Parent>>) -> Self {
        Self {
            node,
            _marker: PhantomData,
        }
    }
    pub fn from_data<A>(data: Spec::Data, allocator: &mut A) -> Self
    where
        A: Allocator<BstNode<Spec::Data, Spec::Parent>>,
    {
        Self::new(allocator.allocate(BstNode::new(data)))
    }
    pub fn borrow_mut(&mut self) -> BstNodeRef<marker::Mut<'_>, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
    pub fn borrow_datamut(&mut self) -> BstNodeRef<marker::DataMut<'_>, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
    pub fn into_dying(self) -> BstNodeRef<marker::Dying, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
}

impl<'a, Spec> BstNodeRef<marker::Immut<'a>, Spec>
where
    Spec: BstSpec<Parent: 'a, Data: 'a>,
{
    pub fn into_data(self) -> &'a Spec::Data {
        unsafe { &self.node.as_ref().data }
    }

    pub fn traverse<F>(self, f: &mut F)
    where
        F: FnMut(Self),
    {
        if let Ok(left) = self.left().descend() {
            left.traverse(f);
        }
        f(self);
        if let Ok(right) = self.right().descend() {
            right.traverse(f);
        }
    }

    pub fn leftmost(self) -> Self {
        let mut node = self;
        while let Ok(left) = node.left().descend() {
            node = left;
        }
        node
    }

    pub fn rightmost(self) -> Self {
        let mut node = self;
        while let Ok(right) = node.right().descend() {
            node = right;
        }
        node
    }
}

impl<'a, Spec> BstNodeRef<marker::DataMut<'a>, Spec>
where
    Spec: BstSpec,
{
    pub fn reborrow_datamut(&mut self) -> BstNodeRef<marker::DataMut<'_>, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
    pub fn data_mut(&mut self) -> &mut Spec::Data {
        unsafe { &mut self.node.as_mut().data }
    }

    pub fn swap_children(&mut self) {
        unsafe { self.node.as_mut().child.swap(0, 1) };
    }
}

impl<'a, Spec> BstNodeRef<marker::DataMut<'a>, Spec>
where
    Spec: BstSpec<Parent: 'a, Data: 'a>,
{
    pub fn into_data_mut(mut self) -> &'a mut Spec::Data {
        unsafe { &mut self.node.as_mut().data }
    }
}

impl<'a, Spec> BstNodeRef<marker::Mut<'a>, Spec>
where
    Spec: BstSpec,
{
    pub fn reborrow_datamut(&mut self) -> BstNodeRef<marker::DataMut<'_>, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }

    pub fn left_mut(&mut self) -> BstEdgeHandle<BstNodeRef<marker::Mut<'_>, Spec>, marker::Left> {
        BstEdgeHandle {
            node: BstNodeRef {
                node: self.node,
                _marker: PhantomData,
            },
            _marker: PhantomData,
        }
    }

    pub fn right_mut(&mut self) -> BstEdgeHandle<BstNodeRef<marker::Mut<'_>, Spec>, marker::Right> {
        BstEdgeHandle {
            node: BstNodeRef {
                node: self.node,
                _marker: PhantomData,
            },
            _marker: PhantomData,
        }
    }
}

impl<'a, Spec> BstNodeRef<marker::Mut<'a>, Spec>
where
    Spec: BstSpec<Data: 'a>,
{
    pub fn dormant(self) -> BstNodeRef<marker::DormantMut, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
}

impl<Spec> BstNodeRef<marker::DormantMut, Spec>
where
    Spec: BstSpec,
{
    pub unsafe fn awaken<'a>(self) -> BstNodeRef<marker::Mut<'a>, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
}

impl<Spec> BstNodeRef<marker::Dying, Spec>
where
    Spec: BstSpec,
{
    pub unsafe fn into_data<A>(self, allocator: &mut A) -> Spec::Data
    where
        A: Allocator<BstNode<Spec::Data, Spec::Parent>>,
    {
        debug_assert!(self.reborrow().left().descend().is_err());
        debug_assert!(self.reborrow().right().descend().is_err());
        allocator.deallocate(self.node).data
    }

crates/competitive/src/data_structure/implicit_splay_tree.rs (line 118)

    fn top_down(mut node: BstDataMutRef<'_, Self>) {
        if !T::is_act_unit(&node.reborrow().into_data().value.act) {
            let act = replace(&mut node.data_mut().value.act, T::act_unit());
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::update_act(left, &act);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::update_act(right, &act);
            }
        }
        if node.reborrow().into_data().rev {
            node.data_mut().rev = false;
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::reverse(left);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::reverse(right);
            }
        }
    }

    fn bottom_up(mut node: BstDataMutRef<'_, Self>) {
        let mut agg = T::single_agg(&node.reborrow().into_data().value.key);
        let mut size = 1;
        if let Ok(left) = node.reborrow().left().descend() {
            let data = left.into_data();
            agg = T::agg_operate(&data.value.agg, &agg);
            size += data.size;
        }
        if let Ok(right) = node.reborrow().right().descend() {
            let data = right.into_data();
            agg = T::agg_operate(&agg, &data.value.agg);
            size += data.size;
        }
        let data = node.data_mut();
        data.value.agg = agg;
        data.size = size;
    }

crates/competitive/src/data_structure/implicit_treap.rs (line 119)

    fn top_down(mut node: BstDataMutRef<'_, Self>) {
        if !T::is_act_unit(&node.reborrow().into_data().value.act) {
            let act = replace(&mut node.data_mut().value.act, T::act_unit());
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::update_act(left, &act);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::update_act(right, &act);
            }
        }
        if node.reborrow().into_data().rev {
            node.data_mut().rev = false;
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::reverse(left);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::reverse(right);
            }
        }
    }

    fn bottom_up(mut node: BstDataMutRef<'_, Self>) {
        let mut agg = T::single_agg(&node.reborrow().into_data().value.key);
        let mut size = 1;
        if let Ok(left) = node.reborrow().left().descend() {
            let data = left.into_data();
            agg = T::agg_operate(&data.value.agg, &agg);
            size += data.size;
        }
        if let Ok(right) = node.reborrow().right().descend() {
            let data = right.into_data();
            agg = T::agg_operate(&agg, &data.value.agg);
            size += data.size;
        }
        let data = node.data_mut();
        data.value.agg = agg;
        data.size = size;
    }

    fn merge(
        left: Option<ImplicitTreapRoot<T>>,
        right: Option<ImplicitTreapRoot<T>>,
    ) -> Option<ImplicitTreapRoot<T>> {
        match (left, right) {
            (None, None) => None,
            (None, Some(node)) | (Some(node), None) => Some(node),
            (Some(mut left), Some(mut right)) => unsafe {
                if left.reborrow().into_data().priority > right.reborrow().into_data().priority {
                    Self::top_down(left.borrow_datamut());
                    let lr = left.borrow_mut().right().take();
                    let lr = Self::merge(lr, Some(right)).unwrap_unchecked();
                    left.borrow_mut().right().set(lr);
                    Self::bottom_up(left.borrow_datamut());
                    Some(left)
                } else {
                    Self::top_down(right.borrow_datamut());
                    let rl = right.borrow_mut().left().take();
                    let rl = Self::merge(Some(left), rl).unwrap_unchecked();
                    right.borrow_mut().left().set(rl);
                    Self::bottom_up(right.borrow_datamut());
                    Some(right)
                }
            },
        }
    }

    fn split<Seeker>(
        node: Option<ImplicitTreapRoot<T>>,
        mut seeker: Seeker,
        equal_side: EqualSide,
    ) -> (Option<ImplicitTreapRoot<T>>, Option<ImplicitTreapRoot<T>>)
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        match node {
            None => (None, None),
            Some(mut node) => {
                Self::top_down(node.borrow_datamut());
                if equal_side.goes_left(seeker.bst_seek(node.reborrow())) {
                    unsafe {
                        let right = node.borrow_mut().right().take();
                        let (l, r) = Self::split(right, seeker, equal_side);
                        if let Some(l) = l {
                            node.borrow_mut().right().set(l);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (Some(node), r)
                    }
                } else {
                    unsafe {
                        let left = node.borrow_mut().left().take();
                        let (l, r) = Self::split(left, seeker, equal_side);
                        if let Some(r) = r {
                            node.borrow_mut().left().set(r);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (l, Some(node))
                    }
                }
            }
        }
    }
}

pub struct ImplicitTreap<T, A = MemoryPool<ImplicitTreapNode<T>>>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>>,
{
    root: Option<ImplicitTreapRoot<T>>,
    length: usize,
    rng: Xorshift,
    allocator: ManuallyDrop<A>,
    _marker: PhantomData<fn() -> T>,
}

impl<T, A> Default for ImplicitTreap<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>> + Default,
{
    fn default() -> Self {
        Self {
            root: None,
            length: 0,
            rng: Xorshift::new(),
            allocator: ManuallyDrop::new(A::default()),
            _marker: PhantomData,
        }
    }
}

impl<T, A> Drop for ImplicitTreap<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>>,
{
    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }
}

impl<T> ImplicitTreap<T>
where
    T: LazyMapMonoid,
{
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            root: None,
            length: 0,
            rng: Xorshift::new(),
            allocator: ManuallyDrop::new(MemoryPool::with_capacity(capacity)),
            _marker: PhantomData,
        }
    }
}

impl<T, A> ImplicitTreap<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>>,
{
    fn node(&mut self, key: T::Key) -> ImplicitTreapRoot<T> {
        BstRoot::from_data(
            ImplicitTreapData {
                priority: self.rng.rand64(),
                value: LazyMapElement::from_key(key),
                size: 1,
                rev: false,
            },
            self.allocator.deref_mut(),
        )
    }

    fn build<I>(&mut self, iter: I) -> (Option<ImplicitTreapRoot<T>>, usize)
    where
        I: IntoIterator<Item = T::Key>,
    {
        let mut stack = vec![];
        let mut len = 0;
        for key in iter {
            let mut cur = self.node(key).node;
            let mut left = None;
            unsafe {
                while stack
                    .last()
                    .is_some_and(|node: &NonNull<ImplicitTreapNode<T>>| {
                        node.as_ref().data.priority < cur.as_ref().data.priority
                    })
                {
                    left = stack.pop();
                }
                cur.as_mut().child[0] = left;
                if let Some(parent) = stack.last_mut() {
                    parent.as_mut().child[1] = Some(cur);
                }
            }
            stack.push(cur);
            len += 1;
        }
        let root = stack.first().copied().map(BstRoot::new);
        if let Some(mut root) = root {
            Self::build_bottom_up(root.borrow_datamut());
            (Some(root), len)
        } else {
            (None, len)
        }
    }

    fn build_bottom_up(mut node: BstDataMutRef<'_, ImplicitTreapSpec<T>>) {
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::build_bottom_up(left);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::build_bottom_up(right);
        }
        ImplicitTreapSpec::<T>::bottom_up(node);
    }

Additional examples can be found in:

• crates/competitive/src/data_structure/treap.rs

impl<BorrowType, Spec, Data> BstNodeRef<BorrowType, Spec>

where Spec: BstSpec<Data = Data, Parent = WithParent<Data>>, BorrowType: BorrowType,

pub fn ascend(self) -> Result<BstNodeRef<BorrowType, Spec>, Self>

Examples found in repository

crates/competitive/src/data_structure/binary_search_tree/node.rs (line 163)

    pub fn resolve_bottom_up<Spec>(mut node: BstNodeRef<marker::DataMut<'_>, Spec>)
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        loop {
            Spec::bottom_up(node.reborrow_datamut());
            match node.ascend() {
                Ok(parent) => node = parent,
                Err(_) => break,
            }
        }
    }

    pub fn is_root<Spec>(node: BstNodeRef<marker::Immut<'_>, Spec>) -> bool
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        unsafe { node.node.as_ref().parent.parent.is_none() }
    }

    pub unsafe fn remove_root<Spec>(
        root: &mut Option<BstRoot<Spec>>,
    ) -> Option<BstNodeRef<marker::Owned, Spec>>
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        let mut node = root.take()?;
        unsafe {
            let left = node.borrow_mut().left_mut().take();
            let right = node.borrow_mut().right_mut().take();
            *root = Spec::merge(left, right);
            Spec::bottom_up(node.borrow_datamut());
            Some(node)
        }
    }

    pub unsafe fn remove_not_root<Spec>(
        mut node: BstNodeRef<marker::Mut<'_>, Spec>,
    ) -> BstNodeRef<marker::Owned, Spec>
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        assert!(!Self::is_root(node.reborrow()));
        unsafe {
            let left = node.left_mut().take();
            let right = node.right_mut().take();
            let merged = Spec::merge(left, right);
            let node_inner = node.node;
            let mut parent = node.ascend().unwrap_unchecked();
            let mut node = if let Some(merged) = merged {
                let node = if parent
                    .reborrow()
                    .left()
                    .descend()
                    .is_ok_and(|n| n.node == node_inner)
                {
                    parent.left_mut().replace(merged)
                } else {
                    parent.right_mut().replace(merged)
                };
                Self::resolve_bottom_up(parent.reborrow_datamut());
                node.unwrap_unchecked()
            } else {
                let node = if parent
                    .reborrow()
                    .left()
                    .descend()
                    .is_ok_and(|n| n.node == node_inner)
                {
                    parent.left_mut().take()
                } else {
                    parent.right_mut().take()
                };
                Self::resolve_bottom_up(parent.reborrow_datamut());
                node.unwrap_unchecked()
            };
            Spec::bottom_up(node.borrow_datamut());
            node
        }
    }
}

pub struct BstNodeRef<BorrowType, Spec>
where
    Spec: BstSpec,
{
    pub node: NonNull<BstNode<Spec::Data, Spec::Parent>>,
    _marker: PhantomData<BorrowType>,
}

impl<'a, Spec> Copy for BstNodeRef<marker::Immut<'a>, Spec> where Spec: BstSpec<Data: 'a> {}
impl<'a, Spec> Clone for BstNodeRef<marker::Immut<'a>, Spec>
where
    Spec: BstSpec<Data: 'a>,
{
    fn clone(&self) -> Self {
        *self
    }
}

impl<BorrowType, Spec> BstNodeRef<BorrowType, Spec>
where
    Spec: BstSpec,
    BorrowType: marker::BorrowType,
{
    pub unsafe fn new_unchecked(node: NonNull<BstNode<Spec::Data, Spec::Parent>>) -> Self {
        Self {
            node,
            _marker: PhantomData,
        }
    }
    pub fn reborrow(&self) -> BstNodeRef<marker::Immut<'_>, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
    pub fn left(self) -> BstEdgeHandle<Self, marker::Left> {
        BstEdgeHandle {
            node: self,
            _marker: PhantomData,
        }
    }
    pub fn right(self) -> BstEdgeHandle<Self, marker::Right> {
        BstEdgeHandle {
            node: self,
            _marker: PhantomData,
        }
    }
}

impl<BorrowType, Spec, Data> BstNodeRef<BorrowType, Spec>
where
    Spec: BstSpec<Data = Data, Parent = WithParent<Data>>,
    BorrowType: marker::BorrowType,
{
    pub fn ascend(self) -> Result<BstNodeRef<BorrowType, Spec>, Self> {
        const {
            assert!(BorrowType::TRAVERSAL_PERMIT);
        };
        let parent = unsafe { self.node.as_ref().parent.parent };
        parent
            .map(|node| BstNodeRef {
                node,
                _marker: PhantomData,
            })
            .ok_or(self)
    }
    pub fn root_path(self) -> (Self, Vec<bool>) {
        let mut node = self;
        let mut nn = node.node;
        let mut stack = vec![];
        let root = loop {
            match node.ascend() {
                Ok(parent) => {
                    node = parent;
                    stack.push(
                        node.reborrow()
                            .left()
                            .descend()
                            .is_ok_and(|node| node.node == nn),
                    );
                    nn = node.node;
                }
                Err(node) => {
                    break node;
                }
            }
        };
        (root, stack)
    }

pub fn root_path(self) -> (Self, Vec<bool>)

Examples found in repository

crates/competitive/src/data_structure/binary_search_tree/node.rs (line 144)

    pub fn resolve_top_down<Spec>(node: BstNodeRef<marker::DataMut<'_>, Spec>)
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        unsafe {
            let (mut node, mut stack) = node.root_path();
            while let Some(is_left) = stack.pop() {
                Spec::top_down(node.reborrow_datamut());
                if is_left {
                    node = node.left().descend().unwrap_unchecked();
                } else {
                    node = node.right().descend().unwrap_unchecked();
                }
            }
            Spec::top_down(node.reborrow_datamut());
        }
    }

impl<Spec> BstNodeRef<Owned, Spec>

where Spec: BstSpec,

pub fn new(node: NonNull<BstNode<Spec::Data, Spec::Parent>>) -> Self

Examples found in repository

crates/competitive/src/data_structure/binary_search_tree/node.rs (line 344)

    pub fn from_data<A>(data: Spec::Data, allocator: &mut A) -> Self
    where
        A: Allocator<BstNode<Spec::Data, Spec::Parent>>,
    {
        Self::new(allocator.allocate(BstNode::new(data)))
    }

crates/competitive/src/data_structure/implicit_splay_tree.rs (line 431)

    fn extend<I>(&mut self, iter: I)
    where
        I: IntoIterator<Item = T::Key>,
    {
        let nodes = iter
            .into_iter()
            .map(|key| self.node(key))
            .collect::<Vec<_>>();
        let len = nodes.len();
        let root = if len == 0 {
            None
        } else {
            let mut stack = Vec::with_capacity(64);
            stack.push((0, len, None::<(usize, usize)>, false));
            while let Some((start, end, parent, visited)) = stack.pop() {
                if start == end {
                    continue;
                }
                let mid = start + (end - start) / 2;
                if visited {
                    ImplicitSplayTreeSpec::bottom_up(
                        BstRoot::new(nodes[mid].node).borrow_datamut(),
                    );
                    continue;
                }
                if let Some((parent, direction)) = parent {
                    let mut parent = nodes[parent].node;
                    unsafe { parent.as_mut().child[direction] = Some(nodes[mid].node) };
                }
                stack.push((start, end, parent, true));
                stack.push((mid + 1, end, Some((mid, 1)), false));
                stack.push((start, mid, Some((mid, 0)), false));
            }
            Some(BstRoot::new(nodes[len / 2].node))
        };
        self.root = ImplicitSplayTreeSpec::merge(self.root.take(), root);
        self.length += len;
    }

crates/competitive/src/data_structure/splay_operations.rs (line 376)

pub fn splay<Spec, Data, Seeker>(
    root: BstRoot<Spec>,
    mut seeker: Seeker,
) -> (Ordering, BstRoot<Spec>)
where
    Spec: BstSpec<Data = Data, Parent = WithNoParent<Data>>,
    Seeker: BstSeeker<Spec = Spec>,
{
    let mut root = root;
    let mut left_subtree = None;
    let mut right_subtree = None;
    let mut left_entry = &mut left_subtree;
    let mut right_entry = &mut right_subtree;
    let mut inline_stack = [None; 24];
    let mut inline_len = 0;
    let mut overflow_stack = vec![];

    macro_rules! push_node {
        ($node:expr) => {
            if inline_len < inline_stack.len() {
                inline_stack[inline_len] = Some($node);
                inline_len += 1;
            } else {
                overflow_stack.push($node);
            }
        };
    }

    macro_rules! add {
        (@left $node:ident) => {
            *left_entry = Some($node.node);
            push_node!($node.node);
            left_entry = unsafe { &mut $node.node.as_mut().child[1] };
        };
        (@right $node:ident) => {
            *right_entry = Some($node.node);
            push_node!($node.node);
            right_entry = unsafe { &mut $node.node.as_mut().child[0] };
        };
    }

    let root_ordering = loop {
        Spec::top_down(root.borrow_datamut());
        match seeker.bst_seek(root.reborrow()) {
            Ordering::Greater => {
                let Some(mut child) = (unsafe { root.borrow_mut().left_mut().take() }) else {
                    break Ordering::Greater;
                };
                Spec::top_down(child.borrow_datamut());
                match seeker.bst_seek(child.reborrow()) {
                    Ordering::Greater => {
                        let Some(mut grandchild) =
                            (unsafe { child.borrow_mut().left_mut().take() })
                        else {
                            add!(@right root);
                            root = child;
                            break Ordering::Greater;
                        };
                        Spec::top_down(grandchild.borrow_datamut());
                        let child_right = unsafe { child.borrow_mut().right_mut().take() };
                        if let Some(child_right) = child_right {
                            unsafe { root.borrow_mut().left_mut().set(child_right) };
                        }
                        Spec::bottom_up(root.borrow_datamut());
                        unsafe { child.borrow_mut().right_mut().set(root) };
                        add!(@right child);
                        root = grandchild;
                    }
                    Ordering::Equal => {
                        add!(@right root);
                        root = child;
                        break Ordering::Equal;
                    }
                    Ordering::Less => {
                        let Some(mut grandchild) =
                            (unsafe { child.borrow_mut().right_mut().take() })
                        else {
                            add!(@right root);
                            root = child;
                            break Ordering::Less;
                        };
                        Spec::top_down(grandchild.borrow_datamut());
                        add!(@right root);
                        add!(@left child);
                        root = grandchild;
                    }
                }
            }
            Ordering::Equal => break Ordering::Equal,
            Ordering::Less => {
                let Some(mut child) = (unsafe { root.borrow_mut().right_mut().take() }) else {
                    break Ordering::Less;
                };
                Spec::top_down(child.borrow_datamut());
                match seeker.bst_seek(child.reborrow()) {
                    Ordering::Greater => {
                        let Some(mut grandchild) =
                            (unsafe { child.borrow_mut().left_mut().take() })
                        else {
                            add!(@left root);
                            root = child;
                            break Ordering::Greater;
                        };
                        Spec::top_down(grandchild.borrow_datamut());
                        add!(@left root);
                        add!(@right child);
                        root = grandchild;
                    }
                    Ordering::Equal => {
                        add!(@left root);
                        root = child;
                        break Ordering::Equal;
                    }
                    Ordering::Less => {
                        let Some(mut grandchild) =
                            (unsafe { child.borrow_mut().right_mut().take() })
                        else {
                            add!(@left root);
                            root = child;
                            break Ordering::Less;
                        };
                        Spec::top_down(grandchild.borrow_datamut());
                        let child_left = unsafe { child.borrow_mut().left_mut().take() };
                        if let Some(child_left) = child_left {
                            unsafe { root.borrow_mut().right_mut().set(child_left) };
                        }
                        Spec::bottom_up(root.borrow_datamut());
                        unsafe { child.borrow_mut().left_mut().set(root) };
                        add!(@left child);
                        root = grandchild;
                    }
                }
            }
        }
    };

    *left_entry = unsafe { root.borrow_mut().left_mut().take() }.map(|node| node.node);
    *right_entry = unsafe { root.borrow_mut().right_mut().take() }.map(|node| node.node);
    unsafe {
        root.node.as_mut().child[0] = left_subtree;
        root.node.as_mut().child[1] = right_subtree;
        while let Some(node) = overflow_stack.pop() {
            Spec::bottom_up(BstRoot::new(node).borrow_datamut());
        }
        while inline_len > 0 {
            inline_len -= 1;
            let node = inline_stack[inline_len].unwrap_unchecked();
            Spec::bottom_up(BstRoot::new(node).borrow_datamut());
        }
    }
    Spec::bottom_up(root.borrow_datamut());
    (root_ordering, root)
}

pub fn from_data<A>(data: Spec::Data, allocator: &mut A) -> Self

where A: Allocator<BstNode<Spec::Data, Spec::Parent>>,

Examples found in repository

crates/competitive/src/data_structure/implicit_splay_tree.rs (lines 238-245)

    fn node(&mut self, key: T::Key) -> ImplicitSplayTreeRoot<T> {
        BstRoot::from_data(
            ImplicitSplayTreeData {
                value: LazyMapElement::from_key(key),
                size: 1,
                rev: false,
            },
            self.allocator.deref_mut(),
        )
    }

crates/competitive/src/data_structure/implicit_treap.rs (lines 285-293)

    fn node(&mut self, key: T::Key) -> ImplicitTreapRoot<T> {
        BstRoot::from_data(
            ImplicitTreapData {
                priority: self.rng.rand64(),
                value: LazyMapElement::from_key(key),
                size: 1,
                rev: false,
            },
            self.allocator.deref_mut(),
        )
    }

crates/competitive/src/data_structure/treap.rs (line 374)

    pub fn insert(&mut self, key: M::Key, value: L::Key) -> BstNodeId<TreapSpec<M, L>> {
        let (left, right) =
            TreapSpec::split(self.root.take(), SeekByKey::new(&key), EqualSide::Right);
        let data = TreapData {
            priority: self.rng.rand64(),
            key: MonoidActElement::from_key(key),
            value: LazyMapElement::from_key(value),
        };
        let node = BstRoot::from_data(data, self.allocator.deref_mut());
        let node_id = self.node_id_manager.register(&node);
        self.root = TreapSpec::merge(TreapSpec::merge(left, Some(node)), right);
        node_id
    }

crates/competitive/src/data_structure/splay_tree.rs (lines 249-256)

    pub fn insert(&mut self, key: K, value: V) -> Option<V>
    where
        K: Ord,
    {
        let ordering = self.splay_by_key(&key);
        if matches!(ordering, Some(Ordering::Equal)) {
            return Some(replace(
                &mut self
                    .root
                    .as_mut()
                    .unwrap()
                    .borrow_datamut()
                    .data_mut()
                    .value,
                value,
            ));
        }
        let mut node = BstRoot::from_data(
            SplayTreeData {
                key,
                value,
                size: 1,
            },
            self.allocator.deref_mut(),
        );
        if let Some(mut root) = self.root.take() {
            match ordering.unwrap() {
                Ordering::Greater => {
                    let left = unsafe { root.borrow_mut().left_mut().take() };
                    if let Some(left) = left {
                        unsafe { node.borrow_mut().left_mut().set(left) };
                    }
                    SplayTreeSpec::bottom_up(root.borrow_datamut());
                    unsafe { node.borrow_mut().right_mut().set(root) };
                }
                Ordering::Less => {
                    let right = unsafe { root.borrow_mut().right_mut().take() };
                    if let Some(right) = right {
                        unsafe { node.borrow_mut().right_mut().set(right) };
                    }
                    SplayTreeSpec::bottom_up(root.borrow_datamut());
                    unsafe { node.borrow_mut().left_mut().set(root) };
                }
                Ordering::Equal => unreachable!(),
            }
            SplayTreeSpec::bottom_up(node.borrow_datamut());
        }
        self.root = Some(node);
        self.length += 1;
        None
    }

pub fn borrow_mut(&mut self) -> BstNodeRef<Mut<'_>, Spec>

Examples found in repository

crates/competitive/src/data_structure/binary_search_tree/node.rs (line 185)

    pub unsafe fn remove_root<Spec>(
        root: &mut Option<BstRoot<Spec>>,
    ) -> Option<BstNodeRef<marker::Owned, Spec>>
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        let mut node = root.take()?;
        unsafe {
            let left = node.borrow_mut().left_mut().take();
            let right = node.borrow_mut().right_mut().take();
            *root = Spec::merge(left, right);
            Spec::bottom_up(node.borrow_datamut());
            Some(node)
        }
    }

    pub unsafe fn remove_not_root<Spec>(
        mut node: BstNodeRef<marker::Mut<'_>, Spec>,
    ) -> BstNodeRef<marker::Owned, Spec>
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        assert!(!Self::is_root(node.reborrow()));
        unsafe {
            let left = node.left_mut().take();
            let right = node.right_mut().take();
            let merged = Spec::merge(left, right);
            let node_inner = node.node;
            let mut parent = node.ascend().unwrap_unchecked();
            let mut node = if let Some(merged) = merged {
                let node = if parent
                    .reborrow()
                    .left()
                    .descend()
                    .is_ok_and(|n| n.node == node_inner)
                {
                    parent.left_mut().replace(merged)
                } else {
                    parent.right_mut().replace(merged)
                };
                Self::resolve_bottom_up(parent.reborrow_datamut());
                node.unwrap_unchecked()
            } else {
                let node = if parent
                    .reborrow()
                    .left()
                    .descend()
                    .is_ok_and(|n| n.node == node_inner)
                {
                    parent.left_mut().take()
                } else {
                    parent.right_mut().take()
                };
                Self::resolve_bottom_up(parent.reborrow_datamut());
                node.unwrap_unchecked()
            };
            Spec::bottom_up(node.borrow_datamut());
            node
        }
    }
}

pub struct BstNodeRef<BorrowType, Spec>
where
    Spec: BstSpec,
{
    pub node: NonNull<BstNode<Spec::Data, Spec::Parent>>,
    _marker: PhantomData<BorrowType>,
}

impl<'a, Spec> Copy for BstNodeRef<marker::Immut<'a>, Spec> where Spec: BstSpec<Data: 'a> {}
impl<'a, Spec> Clone for BstNodeRef<marker::Immut<'a>, Spec>
where
    Spec: BstSpec<Data: 'a>,
{
    fn clone(&self) -> Self {
        *self
    }
}

impl<BorrowType, Spec> BstNodeRef<BorrowType, Spec>
where
    Spec: BstSpec,
    BorrowType: marker::BorrowType,
{
    pub unsafe fn new_unchecked(node: NonNull<BstNode<Spec::Data, Spec::Parent>>) -> Self {
        Self {
            node,
            _marker: PhantomData,
        }
    }
    pub fn reborrow(&self) -> BstNodeRef<marker::Immut<'_>, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
    pub fn left(self) -> BstEdgeHandle<Self, marker::Left> {
        BstEdgeHandle {
            node: self,
            _marker: PhantomData,
        }
    }
    pub fn right(self) -> BstEdgeHandle<Self, marker::Right> {
        BstEdgeHandle {
            node: self,
            _marker: PhantomData,
        }
    }
}

impl<BorrowType, Spec, Data> BstNodeRef<BorrowType, Spec>
where
    Spec: BstSpec<Data = Data, Parent = WithParent<Data>>,
    BorrowType: marker::BorrowType,
{
    pub fn ascend(self) -> Result<BstNodeRef<BorrowType, Spec>, Self> {
        const {
            assert!(BorrowType::TRAVERSAL_PERMIT);
        };
        let parent = unsafe { self.node.as_ref().parent.parent };
        parent
            .map(|node| BstNodeRef {
                node,
                _marker: PhantomData,
            })
            .ok_or(self)
    }
    pub fn root_path(self) -> (Self, Vec<bool>) {
        let mut node = self;
        let mut nn = node.node;
        let mut stack = vec![];
        let root = loop {
            match node.ascend() {
                Ok(parent) => {
                    node = parent;
                    stack.push(
                        node.reborrow()
                            .left()
                            .descend()
                            .is_ok_and(|node| node.node == nn),
                    );
                    nn = node.node;
                }
                Err(node) => {
                    break node;
                }
            }
        };
        (root, stack)
    }
}

impl<Spec> BstNodeRef<marker::Owned, Spec>
where
    Spec: BstSpec,
{
    pub fn new(node: NonNull<BstNode<Spec::Data, Spec::Parent>>) -> Self {
        Self {
            node,
            _marker: PhantomData,
        }
    }
    pub fn from_data<A>(data: Spec::Data, allocator: &mut A) -> Self
    where
        A: Allocator<BstNode<Spec::Data, Spec::Parent>>,
    {
        Self::new(allocator.allocate(BstNode::new(data)))
    }
    pub fn borrow_mut(&mut self) -> BstNodeRef<marker::Mut<'_>, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
    pub fn borrow_datamut(&mut self) -> BstNodeRef<marker::DataMut<'_>, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
    pub fn into_dying(self) -> BstNodeRef<marker::Dying, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
}

impl<'a, Spec> BstNodeRef<marker::Immut<'a>, Spec>
where
    Spec: BstSpec<Parent: 'a, Data: 'a>,
{
    pub fn into_data(self) -> &'a Spec::Data {
        unsafe { &self.node.as_ref().data }
    }

    pub fn traverse<F>(self, f: &mut F)
    where
        F: FnMut(Self),
    {
        if let Ok(left) = self.left().descend() {
            left.traverse(f);
        }
        f(self);
        if let Ok(right) = self.right().descend() {
            right.traverse(f);
        }
    }

    pub fn leftmost(self) -> Self {
        let mut node = self;
        while let Ok(left) = node.left().descend() {
            node = left;
        }
        node
    }

    pub fn rightmost(self) -> Self {
        let mut node = self;
        while let Ok(right) = node.right().descend() {
            node = right;
        }
        node
    }
}

impl<'a, Spec> BstNodeRef<marker::DataMut<'a>, Spec>
where
    Spec: BstSpec,
{
    pub fn reborrow_datamut(&mut self) -> BstNodeRef<marker::DataMut<'_>, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
    pub fn data_mut(&mut self) -> &mut Spec::Data {
        unsafe { &mut self.node.as_mut().data }
    }

    pub fn swap_children(&mut self) {
        unsafe { self.node.as_mut().child.swap(0, 1) };
    }
}

impl<'a, Spec> BstNodeRef<marker::DataMut<'a>, Spec>
where
    Spec: BstSpec<Parent: 'a, Data: 'a>,
{
    pub fn into_data_mut(mut self) -> &'a mut Spec::Data {
        unsafe { &mut self.node.as_mut().data }
    }
}

impl<'a, Spec> BstNodeRef<marker::Mut<'a>, Spec>
where
    Spec: BstSpec,
{
    pub fn reborrow_datamut(&mut self) -> BstNodeRef<marker::DataMut<'_>, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }

    pub fn left_mut(&mut self) -> BstEdgeHandle<BstNodeRef<marker::Mut<'_>, Spec>, marker::Left> {
        BstEdgeHandle {
            node: BstNodeRef {
                node: self.node,
                _marker: PhantomData,
            },
            _marker: PhantomData,
        }
    }

    pub fn right_mut(&mut self) -> BstEdgeHandle<BstNodeRef<marker::Mut<'_>, Spec>, marker::Right> {
        BstEdgeHandle {
            node: BstNodeRef {
                node: self.node,
                _marker: PhantomData,
            },
            _marker: PhantomData,
        }
    }
}

impl<'a, Spec> BstNodeRef<marker::Mut<'a>, Spec>
where
    Spec: BstSpec<Data: 'a>,
{
    pub fn dormant(self) -> BstNodeRef<marker::DormantMut, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
}

impl<Spec> BstNodeRef<marker::DormantMut, Spec>
where
    Spec: BstSpec,
{
    pub unsafe fn awaken<'a>(self) -> BstNodeRef<marker::Mut<'a>, Spec> {
        BstNodeRef {
            node: self.node,
            _marker: PhantomData,
        }
    }
}

impl<Spec> BstNodeRef<marker::Dying, Spec>
where
    Spec: BstSpec,
{
    pub unsafe fn into_data<A>(self, allocator: &mut A) -> Spec::Data
    where
        A: Allocator<BstNode<Spec::Data, Spec::Parent>>,
    {
        debug_assert!(self.reborrow().left().descend().is_err());
        debug_assert!(self.reborrow().right().descend().is_err());
        allocator.deallocate(self.node).data
    }

    pub unsafe fn drop_all<A>(self, allocator: &mut A)
    where
        A: Allocator<BstNode<Spec::Data, Spec::Parent>>,
    {
        let mut stack = vec![self.node];
        while let Some(node) = stack.pop() {
            stack.extend(allocator.deallocate(node).child.into_iter().flatten());
        }
    }
}

pub struct BstEdgeHandle<Node, Dir> {
    node: Node,
    _marker: PhantomData<Dir>,
}

impl<BorrowType, Spec, Dir> BstEdgeHandle<BstNodeRef<BorrowType, Spec>, Dir>
where
    Spec: BstSpec,
    BorrowType: marker::BorrowType,
    Dir: marker::BstDirection,
{
    pub fn descend(self) -> Result<BstNodeRef<BorrowType, Spec>, Self> {
        const {
            assert!(BorrowType::TRAVERSAL_PERMIT);
        };
        let child = unsafe { self.node.node.as_ref().child.get_unchecked(Dir::IDX) };
        child
            .map(|node| BstNodeRef {
                node,
                _marker: PhantomData,
            })
            .ok_or(self)
    }
}

impl<'a, Spec, Dir> BstEdgeHandle<BstNodeRef<marker::Mut<'a>, Spec>, Dir>
where
    Spec: BstSpec,
    Dir: marker::BstDirection,
{
    pub unsafe fn take(&mut self) -> Option<BstNodeRef<marker::Owned, Spec>> {
        let child = unsafe { self.node.node.as_mut().child.get_unchecked_mut(Dir::IDX) };
        child.take().map(|node| {
            let mut node = BstNodeRef {
                node,
                _marker: PhantomData,
            };
            Spec::Parent::take_parent(node.borrow_mut());
            node
        })
    }
    pub unsafe fn replace(
        &mut self,
        mut other: BstNodeRef<marker::Owned, Spec>,
    ) -> Option<BstNodeRef<marker::Owned, Spec>> {
        let child = unsafe { self.node.node.as_mut().child.get_unchecked_mut(Dir::IDX) };
        Spec::Parent::set_parent(other.borrow_mut(), Some(self.node.node));
        child.replace(other.node).map(|node| {
            let mut node = BstNodeRef {
                node,
                _marker: PhantomData,
            };
            Spec::Parent::take_parent(node.borrow_mut());
            node
        })
    }
    pub unsafe fn set(&mut self, mut other: BstNodeRef<marker::Owned, Spec>) {
        let child = unsafe { self.node.node.as_mut().child.get_unchecked_mut(Dir::IDX) };
        Spec::Parent::set_parent(other.borrow_mut(), Some(self.node.node));
        *child = Some(other.node);
    }

crates/competitive/src/data_structure/implicit_splay_tree.rs (line 327)

    pub fn insert(&mut self, index: usize, key: T::Key) {
        assert!(index <= self.length);
        let mut node = self.node(key);
        if self.root.is_none() {
            self.root = Some(node);
        } else if index == self.length {
            self.splay(SeekBySize::new(index));
            unsafe { node.borrow_mut().left_mut().set(self.root.take().unwrap()) };
            ImplicitSplayTreeSpec::bottom_up(node.borrow_datamut());
            self.root = Some(node);
        } else {
            self.splay(SeekBySize::new(index));
            let mut root = self.root.take().unwrap();
            let left = unsafe { root.borrow_mut().left_mut().take() };
            if let Some(left) = left {
                unsafe { node.borrow_mut().left_mut().set(left) };
            }
            ImplicitSplayTreeSpec::bottom_up(root.borrow_datamut());
            unsafe { node.borrow_mut().right_mut().set(root) };
            ImplicitSplayTreeSpec::bottom_up(node.borrow_datamut());
            self.root = Some(node);
        }
        self.length += 1;
    }

    pub fn remove(&mut self, index: usize) -> Option<T::Key> {
        if index >= self.length {
            return None;
        }
        self.splay(SeekBySize::new(index));
        let mut node = self.root.take().unwrap();
        ImplicitSplayTreeSpec::top_down(node.borrow_datamut());
        let left = unsafe { node.borrow_mut().left_mut().take() };
        let right = unsafe { node.borrow_mut().right_mut().take() };
        self.root = ImplicitSplayTreeSpec::merge(left, right);
        self.length -= 1;
        let data = unsafe { node.into_dying().into_data(self.allocator.deref_mut()) };
        Some(data.value.key)
    }

crates/competitive/src/data_structure/implicit_treap.rs (line 162)

    fn merge(
        left: Option<ImplicitTreapRoot<T>>,
        right: Option<ImplicitTreapRoot<T>>,
    ) -> Option<ImplicitTreapRoot<T>> {
        match (left, right) {
            (None, None) => None,
            (None, Some(node)) | (Some(node), None) => Some(node),
            (Some(mut left), Some(mut right)) => unsafe {
                if left.reborrow().into_data().priority > right.reborrow().into_data().priority {
                    Self::top_down(left.borrow_datamut());
                    let lr = left.borrow_mut().right().take();
                    let lr = Self::merge(lr, Some(right)).unwrap_unchecked();
                    left.borrow_mut().right().set(lr);
                    Self::bottom_up(left.borrow_datamut());
                    Some(left)
                } else {
                    Self::top_down(right.borrow_datamut());
                    let rl = right.borrow_mut().left().take();
                    let rl = Self::merge(Some(left), rl).unwrap_unchecked();
                    right.borrow_mut().left().set(rl);
                    Self::bottom_up(right.borrow_datamut());
                    Some(right)
                }
            },
        }
    }

    fn split<Seeker>(
        node: Option<ImplicitTreapRoot<T>>,
        mut seeker: Seeker,
        equal_side: EqualSide,
    ) -> (Option<ImplicitTreapRoot<T>>, Option<ImplicitTreapRoot<T>>)
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        match node {
            None => (None, None),
            Some(mut node) => {
                Self::top_down(node.borrow_datamut());
                if equal_side.goes_left(seeker.bst_seek(node.reborrow())) {
                    unsafe {
                        let right = node.borrow_mut().right().take();
                        let (l, r) = Self::split(right, seeker, equal_side);
                        if let Some(l) = l {
                            node.borrow_mut().right().set(l);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (Some(node), r)
                    }
                } else {
                    unsafe {
                        let left = node.borrow_mut().left().take();
                        let (l, r) = Self::split(left, seeker, equal_side);
                        if let Some(r) = r {
                            node.borrow_mut().left().set(r);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (l, Some(node))
                    }
                }
            }
        }
    }

crates/competitive/src/data_structure/treap.rs (line 127)

    fn merge(
        left: Option<TreapRoot<M, L>>,
        right: Option<TreapRoot<M, L>>,
    ) -> Option<TreapRoot<M, L>> {
        match (left, right) {
            (None, None) => None,
            (None, Some(node)) | (Some(node), None) => Some(node),
            (Some(mut left), Some(mut right)) => unsafe {
                if left.reborrow().into_data().priority > right.reborrow().into_data().priority {
                    TreapSpec::top_down(left.borrow_datamut());
                    let lr = left.borrow_mut().right().take();
                    let lr = Self::merge(lr, Some(right)).unwrap_unchecked();
                    left.borrow_mut().right().set(lr);
                    TreapSpec::bottom_up(left.borrow_datamut());
                    Some(left)
                } else {
                    TreapSpec::top_down(right.borrow_datamut());
                    let rl = right.borrow_mut().left().take();
                    let rl = Self::merge(Some(left), rl).unwrap_unchecked();
                    right.borrow_mut().left().set(rl);
                    TreapSpec::bottom_up(right.borrow_datamut());
                    Some(right)
                }
            },
        }
    }

    fn split<Seeker>(
        node: Option<TreapRoot<M, L>>,
        mut seeker: Seeker,
        equal_side: EqualSide,
    ) -> (Option<TreapRoot<M, L>>, Option<TreapRoot<M, L>>)
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        match node {
            None => (None, None),
            Some(mut node) => {
                Self::top_down(node.borrow_datamut());
                if equal_side.goes_left(seeker.bst_seek(node.reborrow())) {
                    unsafe {
                        let right = node.borrow_mut().right().take();
                        let (l, r) = Self::split(right, seeker, equal_side);
                        if let Some(l) = l {
                            node.borrow_mut().right().set(l);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (Some(node), r)
                    }
                } else {
                    unsafe {
                        let left = node.borrow_mut().left().take();
                        let (l, r) = Self::split(left, seeker, equal_side);
                        if let Some(r) = r {
                            node.borrow_mut().left().set(r);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (l, Some(node))
                    }
                }
            }
        }
    }
}

impl<M, L> TreapSpec<M, L>
where
    M: MonoidAct<Key: Ord>,
    L: LazyMapMonoid,
{
    pub fn merge_ordered(
        left: Option<TreapRoot<M, L>>,
        right: Option<TreapRoot<M, L>>,
    ) -> Option<TreapRoot<M, L>> {
        match (left, right) {
            (None, None) => None,
            (None, Some(node)) | (Some(node), None) => Some(node),
            (Some(mut left), Some(mut right)) => unsafe {
                if left.reborrow().into_data().priority > right.reborrow().into_data().priority {
                    Self::top_down(left.borrow_datamut());
                    let key = &left.reborrow().into_data().key.key;
                    let (rl, rr) = Self::split(Some(right), SeekByKey::new(key), EqualSide::Right);
                    let ll = left.borrow_mut().left().take();
                    let lr = left.borrow_mut().right().take();
                    if let Some(l) = Self::merge_ordered(ll, rl) {
                        left.borrow_mut().left().set(l);
                    }
                    if let Some(r) = Self::merge_ordered(lr, rr) {
                        left.borrow_mut().right().set(r);
                    }
                    Self::bottom_up(left.borrow_datamut());
                    Some(left)
                } else {
                    Self::top_down(right.borrow_datamut());
                    let key = &right.reborrow().into_data().key.key;
                    let (ll, lr) = Self::split(Some(left), SeekByKey::new(key), EqualSide::Right);
                    let rl = right.borrow_mut().left().take();
                    let rr = right.borrow_mut().right().take();
                    if let Some(l) = Self::merge_ordered(ll, rl) {
                        right.borrow_mut().left().set(l);
                    }
                    if let Some(r) = Self::merge_ordered(lr, rr) {
                        right.borrow_mut().right().set(r);
                    }
                    Self::bottom_up(right.borrow_datamut());
                    Some(right)
                }
            },
        }
    }

crates/competitive/src/data_structure/splay_tree.rs (line 260)

    pub fn insert(&mut self, key: K, value: V) -> Option<V>
    where
        K: Ord,
    {
        let ordering = self.splay_by_key(&key);
        if matches!(ordering, Some(Ordering::Equal)) {
            return Some(replace(
                &mut self
                    .root
                    .as_mut()
                    .unwrap()
                    .borrow_datamut()
                    .data_mut()
                    .value,
                value,
            ));
        }
        let mut node = BstRoot::from_data(
            SplayTreeData {
                key,
                value,
                size: 1,
            },
            self.allocator.deref_mut(),
        );
        if let Some(mut root) = self.root.take() {
            match ordering.unwrap() {
                Ordering::Greater => {
                    let left = unsafe { root.borrow_mut().left_mut().take() };
                    if let Some(left) = left {
                        unsafe { node.borrow_mut().left_mut().set(left) };
                    }
                    SplayTreeSpec::bottom_up(root.borrow_datamut());
                    unsafe { node.borrow_mut().right_mut().set(root) };
                }
                Ordering::Less => {
                    let right = unsafe { root.borrow_mut().right_mut().take() };
                    if let Some(right) = right {
                        unsafe { node.borrow_mut().right_mut().set(right) };
                    }
                    SplayTreeSpec::bottom_up(root.borrow_datamut());
                    unsafe { node.borrow_mut().left_mut().set(root) };
                }
                Ordering::Equal => unreachable!(),
            }
            SplayTreeSpec::bottom_up(node.borrow_datamut());
        }
        self.root = Some(node);
        self.length += 1;
        None
    }

    pub fn remove<Q>(&mut self, key: &Q) -> Option<V>
    where
        K: Borrow<Q>,
        Q: Ord + ?Sized,
    {
        if !matches!(self.splay_by_key(key)?, Ordering::Equal) {
            return None;
        }
        Some(self.remove_root().1)
    }

    pub fn remove_at(&mut self, index: usize) -> Option<(K, V)> {
        if index >= self.length {
            return None;
        }
        self.splay_by_size(index);
        Some(self.remove_root())
    }

    fn remove_root(&mut self) -> (K, V) {
        let mut node = self.root.take().unwrap();
        let left = unsafe { node.borrow_mut().left_mut().take() };
        let right = unsafe { node.borrow_mut().right_mut().take() };
        self.root = SplayTreeSpec::merge(left, right);
        self.length -= 1;
        let data = unsafe { node.into_dying().into_data(self.allocator.deref_mut()) };
        (data.key, data.value)
    }

crates/competitive/src/data_structure/splay_operations.rs (line 279)

pub fn splay<Spec, Data, Seeker>(
    root: BstRoot<Spec>,
    mut seeker: Seeker,
) -> (Ordering, BstRoot<Spec>)
where
    Spec: BstSpec<Data = Data, Parent = WithNoParent<Data>>,
    Seeker: BstSeeker<Spec = Spec>,
{
    let mut root = root;
    let mut left_subtree = None;
    let mut right_subtree = None;
    let mut left_entry = &mut left_subtree;
    let mut right_entry = &mut right_subtree;
    let mut inline_stack = [None; 24];
    let mut inline_len = 0;
    let mut overflow_stack = vec![];

    macro_rules! push_node {
        ($node:expr) => {
            if inline_len < inline_stack.len() {
                inline_stack[inline_len] = Some($node);
                inline_len += 1;
            } else {
                overflow_stack.push($node);
            }
        };
    }

    macro_rules! add {
        (@left $node:ident) => {
            *left_entry = Some($node.node);
            push_node!($node.node);
            left_entry = unsafe { &mut $node.node.as_mut().child[1] };
        };
        (@right $node:ident) => {
            *right_entry = Some($node.node);
            push_node!($node.node);
            right_entry = unsafe { &mut $node.node.as_mut().child[0] };
        };
    }

    let root_ordering = loop {
        Spec::top_down(root.borrow_datamut());
        match seeker.bst_seek(root.reborrow()) {
            Ordering::Greater => {
                let Some(mut child) = (unsafe { root.borrow_mut().left_mut().take() }) else {
                    break Ordering::Greater;
                };
                Spec::top_down(child.borrow_datamut());
                match seeker.bst_seek(child.reborrow()) {
                    Ordering::Greater => {
                        let Some(mut grandchild) =
                            (unsafe { child.borrow_mut().left_mut().take() })
                        else {
                            add!(@right root);
                            root = child;
                            break Ordering::Greater;
                        };
                        Spec::top_down(grandchild.borrow_datamut());
                        let child_right = unsafe { child.borrow_mut().right_mut().take() };
                        if let Some(child_right) = child_right {
                            unsafe { root.borrow_mut().left_mut().set(child_right) };
                        }
                        Spec::bottom_up(root.borrow_datamut());
                        unsafe { child.borrow_mut().right_mut().set(root) };
                        add!(@right child);
                        root = grandchild;
                    }
                    Ordering::Equal => {
                        add!(@right root);
                        root = child;
                        break Ordering::Equal;
                    }
                    Ordering::Less => {
                        let Some(mut grandchild) =
                            (unsafe { child.borrow_mut().right_mut().take() })
                        else {
                            add!(@right root);
                            root = child;
                            break Ordering::Less;
                        };
                        Spec::top_down(grandchild.borrow_datamut());
                        add!(@right root);
                        add!(@left child);
                        root = grandchild;
                    }
                }
            }
            Ordering::Equal => break Ordering::Equal,
            Ordering::Less => {
                let Some(mut child) = (unsafe { root.borrow_mut().right_mut().take() }) else {
                    break Ordering::Less;
                };
                Spec::top_down(child.borrow_datamut());
                match seeker.bst_seek(child.reborrow()) {
                    Ordering::Greater => {
                        let Some(mut grandchild) =
                            (unsafe { child.borrow_mut().left_mut().take() })
                        else {
                            add!(@left root);
                            root = child;
                            break Ordering::Greater;
                        };
                        Spec::top_down(grandchild.borrow_datamut());
                        add!(@left root);
                        add!(@right child);
                        root = grandchild;
                    }
                    Ordering::Equal => {
                        add!(@left root);
                        root = child;
                        break Ordering::Equal;
                    }
                    Ordering::Less => {
                        let Some(mut grandchild) =
                            (unsafe { child.borrow_mut().right_mut().take() })
                        else {
                            add!(@left root);
                            root = child;
                            break Ordering::Less;
                        };
                        Spec::top_down(grandchild.borrow_datamut());
                        let child_left = unsafe { child.borrow_mut().left_mut().take() };
                        if let Some(child_left) = child_left {
                            unsafe { root.borrow_mut().right_mut().set(child_left) };
                        }
                        Spec::bottom_up(root.borrow_datamut());
                        unsafe { child.borrow_mut().left_mut().set(root) };
                        add!(@left child);
                        root = grandchild;
                    }
                }
            }
        }
    };

    *left_entry = unsafe { root.borrow_mut().left_mut().take() }.map(|node| node.node);
    *right_entry = unsafe { root.borrow_mut().right_mut().take() }.map(|node| node.node);
    unsafe {
        root.node.as_mut().child[0] = left_subtree;
        root.node.as_mut().child[1] = right_subtree;
        while let Some(node) = overflow_stack.pop() {
            Spec::bottom_up(BstRoot::new(node).borrow_datamut());
        }
        while inline_len > 0 {
            inline_len -= 1;
            let node = inline_stack[inline_len].unwrap_unchecked();
            Spec::bottom_up(BstRoot::new(node).borrow_datamut());
        }
    }
    Spec::bottom_up(root.borrow_datamut());
    (root_ordering, root)
}

#[inline]
pub fn merge<Spec, Data>(
    left: Option<BstRoot<Spec>>,
    right: Option<BstRoot<Spec>>,
) -> Option<BstRoot<Spec>>
where
    Spec: BstSpec<Data = Data, Parent = WithNoParent<Data>>,
{
    match (left, right) {
        (None, None) => None,
        (None, Some(root)) | (Some(root), None) => Some(root),
        (Some(left), Some(mut right)) if right.reborrow().left().descend().is_err() => {
            Spec::top_down(right.borrow_datamut());
            unsafe { right.borrow_mut().left_mut().set(left) };
            Spec::bottom_up(right.borrow_datamut());
            Some(right)
        }
        (Some(left), Some(right)) => {
            let (_, mut root) = splay(left, SeekRight::default());
            unsafe { root.borrow_mut().right_mut().set(right) };
            Spec::bottom_up(root.borrow_datamut());
            Some(root)
        }
    }
}

#[inline]
pub fn split<Spec, Data, Seeker>(
    root: Option<BstRoot<Spec>>,
    seeker: Seeker,
    equal_side: EqualSide,
) -> (Option<BstRoot<Spec>>, Option<BstRoot<Spec>>)
where
    Spec: BstSpec<Data = Data, Parent = WithNoParent<Data>>,
    Seeker: BstSeeker<Spec = Spec>,
{
    let Some(root) = root else {
        return (None, None);
    };
    let (ordering, mut root) = splay(root, seeker);
    if equal_side.goes_left(ordering) {
        let right = unsafe { root.borrow_mut().right_mut().take() };
        Spec::bottom_up(root.borrow_datamut());
        (Some(root), right)
    } else {
        let left = unsafe { root.borrow_mut().left_mut().take() };
        Spec::bottom_up(root.borrow_datamut());
        (left, Some(root))
    }
}

pub fn borrow_datamut(&mut self) -> BstNodeRef<DataMut<'_>, Spec>

Examples found in repository

crates/competitive/src/data_structure/binary_search_tree/split.rs (line 49)

    pub fn left_datamut(&mut self) -> Option<BstDataMutRef<'_, Spec>> {
        self.left.as_mut().map(|node| node.borrow_datamut())
    }

    pub fn right_datamut(&mut self) -> Option<BstDataMutRef<'_, Spec>> {
        self.right.as_mut().map(|node| node.borrow_datamut())
    }

    pub fn manually_merge<F>(&mut self, mut f: F)
    where
        F: FnMut(Option<BstRoot<Spec>>, Option<BstRoot<Spec>>) -> Option<BstRoot<Spec>>,
    {
        self.left = f(self.left.take(), self.right.take());
    }
}

impl<'a, Spec> Drop for Split<'a, Spec>
where
    Spec: BstSpec,
{
    fn drop(&mut self) {
        *self.root = Spec::merge(self.left.take(), self.right.take());
    }
}

pub struct Split3<'a, Spec>
where
    Spec: BstSpec,
{
    left: Option<BstRoot<Spec>>,
    mid: Option<BstRoot<Spec>>,
    right: Option<BstRoot<Spec>>,
    root: &'a mut Option<BstRoot<Spec>>,
}

impl<'a, Spec> Split3<'a, Spec>
where
    Spec: BstSpec,
{
    pub fn new<Seek1, Seek2>(
        node: &'a mut Option<BstRoot<Spec>>,
        start: Bound<Seek1>,
        end: Bound<Seek2>,
    ) -> Self
    where
        Seek1: BstSeeker<Spec = Spec>,
        Seek2: BstSeeker<Spec = Spec>,
    {
        let (mut rest, right) = match end {
            Bound::Included(seeker) => Spec::split(node.take(), seeker, EqualSide::Left),
            Bound::Excluded(seeker) => Spec::split(node.take(), seeker, EqualSide::Right),
            Bound::Unbounded => (node.take(), None),
        };
        let (left, mid) = match start {
            Bound::Included(seeker) => Spec::split(rest.take(), seeker, EqualSide::Right),
            Bound::Excluded(seeker) => Spec::split(rest.take(), seeker, EqualSide::Left),
            Bound::Unbounded => (None, rest),
        };
        Self {
            left,
            mid,
            right,
            root: node,
        }
    }

    pub fn left(&self) -> Option<BstImmutRef<'_, Spec>> {
        self.left.as_ref().map(|node| node.reborrow())
    }

    pub fn mid(&self) -> Option<BstImmutRef<'_, Spec>> {
        self.mid.as_ref().map(|node| node.reborrow())
    }

    pub fn right(&self) -> Option<BstImmutRef<'_, Spec>> {
        self.right.as_ref().map(|node| node.reborrow())
    }

    pub fn left_datamut(&mut self) -> Option<BstDataMutRef<'_, Spec>> {
        self.left.as_mut().map(|node| node.borrow_datamut())
    }

    pub fn mid_datamut(&mut self) -> Option<BstDataMutRef<'_, Spec>> {
        self.mid.as_mut().map(|node| node.borrow_datamut())
    }

    pub fn right_datamut(&mut self) -> Option<BstDataMutRef<'_, Spec>> {
        self.right.as_mut().map(|node| node.borrow_datamut())
    }

crates/competitive/src/data_structure/implicit_splay_tree.rs (line 311)

    pub fn modify<F>(&mut self, index: usize, f: F)
    where
        F: FnOnce(&T::Key) -> T::Key,
    {
        assert!(index < self.length);
        self.splay(SeekBySize::new(index));
        let mut root = self.root.as_mut().unwrap().borrow_datamut();
        ImplicitSplayTreeSpec::top_down(root.reborrow_datamut());
        {
            let data = root.data_mut();
            data.value.key = f(&data.value.key);
        }
        ImplicitSplayTreeSpec::bottom_up(root);
    }

    pub fn insert(&mut self, index: usize, key: T::Key) {
        assert!(index <= self.length);
        let mut node = self.node(key);
        if self.root.is_none() {
            self.root = Some(node);
        } else if index == self.length {
            self.splay(SeekBySize::new(index));
            unsafe { node.borrow_mut().left_mut().set(self.root.take().unwrap()) };
            ImplicitSplayTreeSpec::bottom_up(node.borrow_datamut());
            self.root = Some(node);
        } else {
            self.splay(SeekBySize::new(index));
            let mut root = self.root.take().unwrap();
            let left = unsafe { root.borrow_mut().left_mut().take() };
            if let Some(left) = left {
                unsafe { node.borrow_mut().left_mut().set(left) };
            }
            ImplicitSplayTreeSpec::bottom_up(root.borrow_datamut());
            unsafe { node.borrow_mut().right_mut().set(root) };
            ImplicitSplayTreeSpec::bottom_up(node.borrow_datamut());
            self.root = Some(node);
        }
        self.length += 1;
    }

    pub fn remove(&mut self, index: usize) -> Option<T::Key> {
        if index >= self.length {
            return None;
        }
        self.splay(SeekBySize::new(index));
        let mut node = self.root.take().unwrap();
        ImplicitSplayTreeSpec::top_down(node.borrow_datamut());
        let left = unsafe { node.borrow_mut().left_mut().take() };
        let right = unsafe { node.borrow_mut().right_mut().take() };
        self.root = ImplicitSplayTreeSpec::merge(left, right);
        self.length -= 1;
        let data = unsafe { node.into_dying().into_data(self.allocator.deref_mut()) };
        Some(data.value.key)
    }

    pub fn partition_point_acc<F>(&mut self, left: usize, mut pred: F) -> usize
    where
        F: FnMut(&T::Agg) -> bool,
    {
        let mut split3 = Split3::seek_by_size(&mut self.root, left..);
        let front_size = split3
            .left()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        let split = split3.split_mid(SeekByAccCond::new(|acc| !pred(acc)), EqualSide::Right);
        let index = split
            .left()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        front_size + index
    }

    pub fn rpartition_point_acc<F>(&mut self, right: usize, mut pred: F) -> usize
    where
        F: FnMut(&T::Agg) -> bool,
    {
        let mut split3 = Split3::seek_by_size(&mut self.root, ..right);
        let split = split3.split_mid(SeekByRaccCond::new(|acc| !pred(acc)), EqualSide::Left);
        split
            .left()
            .map(|node| node.into_data().size)
            .unwrap_or_default()
    }

    pub fn rotate_left(&mut self, mid: usize) {
        assert!(mid <= self.length);
        if mid == 0 || mid == self.length {
            return;
        }
        let (left, right) =
            ImplicitSplayTreeSpec::split(self.root.take(), SeekBySize::new(mid), EqualSide::Right);
        self.root = ImplicitSplayTreeSpec::merge(right, left);
    }

    pub fn rotate_right(&mut self, k: usize) {
        assert!(k <= self.length);
        self.rotate_left(self.length - k);
    }
}

impl<T, A> Extend<T::Key> for ImplicitSplayTree<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitSplayTreeNode<T>>,
{
    fn extend<I>(&mut self, iter: I)
    where
        I: IntoIterator<Item = T::Key>,
    {
        let nodes = iter
            .into_iter()
            .map(|key| self.node(key))
            .collect::<Vec<_>>();
        let len = nodes.len();
        let root = if len == 0 {
            None
        } else {
            let mut stack = Vec::with_capacity(64);
            stack.push((0, len, None::<(usize, usize)>, false));
            while let Some((start, end, parent, visited)) = stack.pop() {
                if start == end {
                    continue;
                }
                let mid = start + (end - start) / 2;
                if visited {
                    ImplicitSplayTreeSpec::bottom_up(
                        BstRoot::new(nodes[mid].node).borrow_datamut(),
                    );
                    continue;
                }
                if let Some((parent, direction)) = parent {
                    let mut parent = nodes[parent].node;
                    unsafe { parent.as_mut().child[direction] = Some(nodes[mid].node) };
                }
                stack.push((start, end, parent, true));
                stack.push((mid + 1, end, Some((mid, 1)), false));
                stack.push((start, mid, Some((mid, 0)), false));
            }
            Some(BstRoot::new(nodes[len / 2].node))
        };
        self.root = ImplicitSplayTreeSpec::merge(self.root.take(), root);
        self.length += len;
    }

crates/competitive/src/data_structure/binary_search_tree/node.rs (line 188)

    pub unsafe fn remove_root<Spec>(
        root: &mut Option<BstRoot<Spec>>,
    ) -> Option<BstNodeRef<marker::Owned, Spec>>
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        let mut node = root.take()?;
        unsafe {
            let left = node.borrow_mut().left_mut().take();
            let right = node.borrow_mut().right_mut().take();
            *root = Spec::merge(left, right);
            Spec::bottom_up(node.borrow_datamut());
            Some(node)
        }
    }

    pub unsafe fn remove_not_root<Spec>(
        mut node: BstNodeRef<marker::Mut<'_>, Spec>,
    ) -> BstNodeRef<marker::Owned, Spec>
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        assert!(!Self::is_root(node.reborrow()));
        unsafe {
            let left = node.left_mut().take();
            let right = node.right_mut().take();
            let merged = Spec::merge(left, right);
            let node_inner = node.node;
            let mut parent = node.ascend().unwrap_unchecked();
            let mut node = if let Some(merged) = merged {
                let node = if parent
                    .reborrow()
                    .left()
                    .descend()
                    .is_ok_and(|n| n.node == node_inner)
                {
                    parent.left_mut().replace(merged)
                } else {
                    parent.right_mut().replace(merged)
                };
                Self::resolve_bottom_up(parent.reborrow_datamut());
                node.unwrap_unchecked()
            } else {
                let node = if parent
                    .reborrow()
                    .left()
                    .descend()
                    .is_ok_and(|n| n.node == node_inner)
                {
                    parent.left_mut().take()
                } else {
                    parent.right_mut().take()
                };
                Self::resolve_bottom_up(parent.reborrow_datamut());
                node.unwrap_unchecked()
            };
            Spec::bottom_up(node.borrow_datamut());
            node
        }
    }

crates/competitive/src/data_structure/implicit_treap.rs (line 161)

    fn merge(
        left: Option<ImplicitTreapRoot<T>>,
        right: Option<ImplicitTreapRoot<T>>,
    ) -> Option<ImplicitTreapRoot<T>> {
        match (left, right) {
            (None, None) => None,
            (None, Some(node)) | (Some(node), None) => Some(node),
            (Some(mut left), Some(mut right)) => unsafe {
                if left.reborrow().into_data().priority > right.reborrow().into_data().priority {
                    Self::top_down(left.borrow_datamut());
                    let lr = left.borrow_mut().right().take();
                    let lr = Self::merge(lr, Some(right)).unwrap_unchecked();
                    left.borrow_mut().right().set(lr);
                    Self::bottom_up(left.borrow_datamut());
                    Some(left)
                } else {
                    Self::top_down(right.borrow_datamut());
                    let rl = right.borrow_mut().left().take();
                    let rl = Self::merge(Some(left), rl).unwrap_unchecked();
                    right.borrow_mut().left().set(rl);
                    Self::bottom_up(right.borrow_datamut());
                    Some(right)
                }
            },
        }
    }

    fn split<Seeker>(
        node: Option<ImplicitTreapRoot<T>>,
        mut seeker: Seeker,
        equal_side: EqualSide,
    ) -> (Option<ImplicitTreapRoot<T>>, Option<ImplicitTreapRoot<T>>)
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        match node {
            None => (None, None),
            Some(mut node) => {
                Self::top_down(node.borrow_datamut());
                if equal_side.goes_left(seeker.bst_seek(node.reborrow())) {
                    unsafe {
                        let right = node.borrow_mut().right().take();
                        let (l, r) = Self::split(right, seeker, equal_side);
                        if let Some(l) = l {
                            node.borrow_mut().right().set(l);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (Some(node), r)
                    }
                } else {
                    unsafe {
                        let left = node.borrow_mut().left().take();
                        let (l, r) = Self::split(left, seeker, equal_side);
                        if let Some(r) = r {
                            node.borrow_mut().left().set(r);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (l, Some(node))
                    }
                }
            }
        }
    }
}

pub struct ImplicitTreap<T, A = MemoryPool<ImplicitTreapNode<T>>>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>>,
{
    root: Option<ImplicitTreapRoot<T>>,
    length: usize,
    rng: Xorshift,
    allocator: ManuallyDrop<A>,
    _marker: PhantomData<fn() -> T>,
}

impl<T, A> Default for ImplicitTreap<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>> + Default,
{
    fn default() -> Self {
        Self {
            root: None,
            length: 0,
            rng: Xorshift::new(),
            allocator: ManuallyDrop::new(A::default()),
            _marker: PhantomData,
        }
    }
}

impl<T, A> Drop for ImplicitTreap<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>>,
{
    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }
}

impl<T> ImplicitTreap<T>
where
    T: LazyMapMonoid,
{
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            root: None,
            length: 0,
            rng: Xorshift::new(),
            allocator: ManuallyDrop::new(MemoryPool::with_capacity(capacity)),
            _marker: PhantomData,
        }
    }
}

impl<T, A> ImplicitTreap<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>>,
{
    fn node(&mut self, key: T::Key) -> ImplicitTreapRoot<T> {
        BstRoot::from_data(
            ImplicitTreapData {
                priority: self.rng.rand64(),
                value: LazyMapElement::from_key(key),
                size: 1,
                rev: false,
            },
            self.allocator.deref_mut(),
        )
    }

    fn build<I>(&mut self, iter: I) -> (Option<ImplicitTreapRoot<T>>, usize)
    where
        I: IntoIterator<Item = T::Key>,
    {
        let mut stack = vec![];
        let mut len = 0;
        for key in iter {
            let mut cur = self.node(key).node;
            let mut left = None;
            unsafe {
                while stack
                    .last()
                    .is_some_and(|node: &NonNull<ImplicitTreapNode<T>>| {
                        node.as_ref().data.priority < cur.as_ref().data.priority
                    })
                {
                    left = stack.pop();
                }
                cur.as_mut().child[0] = left;
                if let Some(parent) = stack.last_mut() {
                    parent.as_mut().child[1] = Some(cur);
                }
            }
            stack.push(cur);
            len += 1;
        }
        let root = stack.first().copied().map(BstRoot::new);
        if let Some(mut root) = root {
            Self::build_bottom_up(root.borrow_datamut());
            (Some(root), len)
        } else {
            (None, len)
        }
    }

    fn build_bottom_up(mut node: BstDataMutRef<'_, ImplicitTreapSpec<T>>) {
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::build_bottom_up(left);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::build_bottom_up(right);
        }
        ImplicitTreapSpec::<T>::bottom_up(node);
    }

    pub fn len(&self) -> usize {
        self.length
    }

    pub fn is_empty(&self) -> bool {
        self.length == 0
    }

    pub fn update<R>(&mut self, range: R, x: T::Act)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitTreapSpec::<T>::update_act(root, &x);
        }
    }

    pub fn fold<R>(&mut self, range: R) -> T::Agg
    where
        R: RangeBounds<usize>,
    {
        let split = Split3::seek_by_size(&mut self.root, range);
        split
            .mid()
            .map(|node| node.into_data().value.agg.clone())
            .unwrap_or_else(T::agg_unit)
    }

    pub fn reverse<R>(&mut self, range: R)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitTreapSpec::<T>::reverse(root);
        }
    }

    pub fn get(&mut self, index: usize) -> Option<&T::Key> {
        if index >= self.length {
            return None;
        }
        let split = Split3::seek_by_size(&mut self.root, index..=index);
        let node = split.mid()?.node;
        drop(split);
        Some(unsafe { &(*node.as_ptr()).data.value.key })
    }

    pub fn modify<F>(&mut self, index: usize, f: F)
    where
        F: FnOnce(&T::Key) -> T::Key,
    {
        assert!(index < self.length);
        let mut split = Split3::seek_by_size(&mut self.root, index..=index);
        let mut node = split.mid_datamut().unwrap();
        ImplicitTreapSpec::<T>::top_down(node.reborrow_datamut());
        {
            let data = node.data_mut();
            data.value.key = f(&data.value.key);
        }
        ImplicitTreapSpec::<T>::bottom_up(node);
    }

    pub fn insert(&mut self, index: usize, x: T::Key) {
        assert!(index <= self.length);
        let node = self.node(x);
        if index == 0 {
            self.root = ImplicitTreapSpec::<T>::merge(Some(node), self.root.take());
        } else if index == self.length {
            self.root = ImplicitTreapSpec::<T>::merge(self.root.take(), Some(node));
        } else {
            let mut node = Some(node);
            let mut split = Split::new(&mut self.root, SeekBySize::new(index), EqualSide::Right);
            split.manually_merge(|left, right| {
                ImplicitTreapSpec::<T>::merge(
                    ImplicitTreapSpec::<T>::merge(left, node.take()),
                    right,
                )
            });
        }
        self.length += 1;
    }

    pub fn remove(&mut self, index: usize) -> Option<T::Key> {
        if index >= self.length {
            return None;
        }
        let mid;
        if index == 0 {
            let (left, right) = ImplicitTreapSpec::<T>::split(
                self.root.take(),
                SeekBySize::new(1),
                EqualSide::Right,
            );
            mid = left;
            self.root = right;
        } else if index + 1 == self.length {
            let (left, right) = ImplicitTreapSpec::<T>::split(
                self.root.take(),
                SeekBySize::new(index),
                EqualSide::Right,
            );
            mid = right;
            self.root = left;
        } else {
            let (left, rest) = ImplicitTreapSpec::<T>::split(
                self.root.take(),
                SeekBySize::new(index),
                EqualSide::Right,
            );
            let (middle, right) =
                ImplicitTreapSpec::<T>::split(rest, SeekBySize::new(1), EqualSide::Right);
            mid = middle;
            self.root = ImplicitTreapSpec::<T>::merge(left, right);
        }
        self.length -= 1;
        let mut node = mid.unwrap();
        ImplicitTreapSpec::<T>::top_down(node.borrow_datamut());
        let data = unsafe { node.into_dying().into_data(self.allocator.deref_mut()) };
        Some(data.value.key)
    }

crates/competitive/src/data_structure/treap.rs (line 126)

    fn merge(
        left: Option<TreapRoot<M, L>>,
        right: Option<TreapRoot<M, L>>,
    ) -> Option<TreapRoot<M, L>> {
        match (left, right) {
            (None, None) => None,
            (None, Some(node)) | (Some(node), None) => Some(node),
            (Some(mut left), Some(mut right)) => unsafe {
                if left.reborrow().into_data().priority > right.reborrow().into_data().priority {
                    TreapSpec::top_down(left.borrow_datamut());
                    let lr = left.borrow_mut().right().take();
                    let lr = Self::merge(lr, Some(right)).unwrap_unchecked();
                    left.borrow_mut().right().set(lr);
                    TreapSpec::bottom_up(left.borrow_datamut());
                    Some(left)
                } else {
                    TreapSpec::top_down(right.borrow_datamut());
                    let rl = right.borrow_mut().left().take();
                    let rl = Self::merge(Some(left), rl).unwrap_unchecked();
                    right.borrow_mut().left().set(rl);
                    TreapSpec::bottom_up(right.borrow_datamut());
                    Some(right)
                }
            },
        }
    }

    fn split<Seeker>(
        node: Option<TreapRoot<M, L>>,
        mut seeker: Seeker,
        equal_side: EqualSide,
    ) -> (Option<TreapRoot<M, L>>, Option<TreapRoot<M, L>>)
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        match node {
            None => (None, None),
            Some(mut node) => {
                Self::top_down(node.borrow_datamut());
                if equal_side.goes_left(seeker.bst_seek(node.reborrow())) {
                    unsafe {
                        let right = node.borrow_mut().right().take();
                        let (l, r) = Self::split(right, seeker, equal_side);
                        if let Some(l) = l {
                            node.borrow_mut().right().set(l);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (Some(node), r)
                    }
                } else {
                    unsafe {
                        let left = node.borrow_mut().left().take();
                        let (l, r) = Self::split(left, seeker, equal_side);
                        if let Some(r) = r {
                            node.borrow_mut().left().set(r);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (l, Some(node))
                    }
                }
            }
        }
    }
}

impl<M, L> TreapSpec<M, L>
where
    M: MonoidAct<Key: Ord>,
    L: LazyMapMonoid,
{
    pub fn merge_ordered(
        left: Option<TreapRoot<M, L>>,
        right: Option<TreapRoot<M, L>>,
    ) -> Option<TreapRoot<M, L>> {
        match (left, right) {
            (None, None) => None,
            (None, Some(node)) | (Some(node), None) => Some(node),
            (Some(mut left), Some(mut right)) => unsafe {
                if left.reborrow().into_data().priority > right.reborrow().into_data().priority {
                    Self::top_down(left.borrow_datamut());
                    let key = &left.reborrow().into_data().key.key;
                    let (rl, rr) = Self::split(Some(right), SeekByKey::new(key), EqualSide::Right);
                    let ll = left.borrow_mut().left().take();
                    let lr = left.borrow_mut().right().take();
                    if let Some(l) = Self::merge_ordered(ll, rl) {
                        left.borrow_mut().left().set(l);
                    }
                    if let Some(r) = Self::merge_ordered(lr, rr) {
                        left.borrow_mut().right().set(r);
                    }
                    Self::bottom_up(left.borrow_datamut());
                    Some(left)
                } else {
                    Self::top_down(right.borrow_datamut());
                    let key = &right.reborrow().into_data().key.key;
                    let (ll, lr) = Self::split(Some(left), SeekByKey::new(key), EqualSide::Right);
                    let rl = right.borrow_mut().left().take();
                    let rr = right.borrow_mut().right().take();
                    if let Some(l) = Self::merge_ordered(ll, rl) {
                        right.borrow_mut().left().set(l);
                    }
                    if let Some(r) = Self::merge_ordered(lr, rr) {
                        right.borrow_mut().right().set(r);
                    }
                    Self::bottom_up(right.borrow_datamut());
                    Some(right)
                }
            },
        }
    }
}

pub struct Treap<M, L, A = BoxAllocator<TreapNode<M, L>>>
where
    M: MonoidAct<Key: Ord>,
    L: LazyMapMonoid,
    A: Allocator<TreapNode<M, L>>,
{
    root: Option<TreapRoot<M, L>>,
    node_id_manager: BstNodeIdManager<TreapSpec<M, L>>,
    rng: Xorshift,
    allocator: ManuallyDrop<A>,
    _marker: PhantomData<(M, L)>,
}

impl<M, L, A> Default for Treap<M, L, A>
where
    M: MonoidAct<Key: Ord>,
    L: LazyMapMonoid,
    A: Allocator<TreapNode<M, L>> + Default,
{
    fn default() -> Self {
        Self {
            root: None,
            node_id_manager: Default::default(),
            rng: Xorshift::new(),
            allocator: ManuallyDrop::new(A::default()),
            _marker: PhantomData,
        }
    }
}

impl<M, L, A> Drop for Treap<M, L, A>
where
    M: MonoidAct<Key: Ord>,
    L: LazyMapMonoid,
    A: Allocator<TreapNode<M, L>>,
{
    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }
}

impl<M, L> Treap<M, L>
where
    M: MonoidAct<Key: Ord>,
    L: LazyMapMonoid,
{
    pub fn new() -> Self {
        Self::default()
    }
}

impl<M, L, A> Treap<M, L, A>
where
    M: MonoidAct<Key: Ord>,
    L: LazyMapMonoid,
    A: Allocator<TreapNode<M, L>>,
{
    pub fn len(&self) -> usize {
        self.node_id_manager.len()
    }

    pub fn is_empty(&self) -> bool {
        self.node_id_manager.is_empty()
    }

    pub fn clear(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            self.node_id_manager.clear();
        }
    }

    pub fn get(&mut self, node_id: BstNodeId<TreapSpec<M, L>>) -> Option<(&M::Key, &L::Key)> {
        if !self.node_id_manager.contains(&node_id) {
            return None;
        }
        unsafe {
            WithParent::resolve_top_down::<TreapSpec<M, L>>(
                node_id.reborrow_datamut(&mut self.root),
            );
            let data = node_id.reborrow(&self.root).into_data();
            Some((&data.key.key, &data.value.key))
        }
    }

    pub fn change(
        &mut self,
        node_id: BstNodeId<TreapSpec<M, L>>,
        f: impl FnOnce(&mut L::Key),
    ) -> bool {
        if !self.node_id_manager.contains(&node_id) {
            return false;
        }
        unsafe {
            WithParent::resolve_top_down::<TreapSpec<M, L>>(
                node_id.reborrow_datamut(&mut self.root),
            );
            let data = node_id.reborrow_datamut(&mut self.root).into_data_mut();
            f(&mut data.value.key);
            WithParent::resolve_bottom_up::<TreapSpec<M, L>>(
                node_id.reborrow_datamut(&mut self.root),
            );
        }
        true
    }

    pub fn change_key_value(
        &mut self,
        node_id: BstNodeId<TreapSpec<M, L>>,
        f: impl FnOnce(&mut M::Key, &mut L::Key),
    ) -> bool {
        if !self.node_id_manager.contains(&node_id) {
            return false;
        }
        unsafe {
            WithParent::resolve_top_down::<TreapSpec<M, L>>(
                node_id.reborrow_datamut(&mut self.root),
            );
            let mut node = if WithParent::is_root(node_id.reborrow(&self.root)) {
                WithParent::remove_root(&mut self.root).unwrap_unchecked()
            } else {
                WithParent::remove_not_root(node_id.reborrow_mut(&mut self.root))
            };
            let data = node.borrow_datamut().into_data_mut();
            f(&mut data.key.key, &mut data.value.key);
            self.root = TreapSpec::merge_ordered(self.root.take(), Some(node));
            true
        }
    }

crates/competitive/src/data_structure/splay_tree.rs (line 243)

    pub fn insert(&mut self, key: K, value: V) -> Option<V>
    where
        K: Ord,
    {
        let ordering = self.splay_by_key(&key);
        if matches!(ordering, Some(Ordering::Equal)) {
            return Some(replace(
                &mut self
                    .root
                    .as_mut()
                    .unwrap()
                    .borrow_datamut()
                    .data_mut()
                    .value,
                value,
            ));
        }
        let mut node = BstRoot::from_data(
            SplayTreeData {
                key,
                value,
                size: 1,
            },
            self.allocator.deref_mut(),
        );
        if let Some(mut root) = self.root.take() {
            match ordering.unwrap() {
                Ordering::Greater => {
                    let left = unsafe { root.borrow_mut().left_mut().take() };
                    if let Some(left) = left {
                        unsafe { node.borrow_mut().left_mut().set(left) };
                    }
                    SplayTreeSpec::bottom_up(root.borrow_datamut());
                    unsafe { node.borrow_mut().right_mut().set(root) };
                }
                Ordering::Less => {
                    let right = unsafe { root.borrow_mut().right_mut().take() };
                    if let Some(right) = right {
                        unsafe { node.borrow_mut().right_mut().set(right) };
                    }
                    SplayTreeSpec::bottom_up(root.borrow_datamut());
                    unsafe { node.borrow_mut().left_mut().set(root) };
                }
                Ordering::Equal => unreachable!(),
            }
            SplayTreeSpec::bottom_up(node.borrow_datamut());
        }
        self.root = Some(node);
        self.length += 1;
        None
    }

Additional examples can be found in:

• crates/competitive/src/data_structure/splay_operations.rs

pub fn into_dying(self) -> BstNodeRef<Dying, Spec>

Examples found in repository

crates/competitive/src/data_structure/implicit_splay_tree.rs (line 207)

    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }
}

impl<T> ImplicitSplayTree<T>
where
    T: LazyMapMonoid,
{
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            root: None,
            length: 0,
            allocator: ManuallyDrop::new(MemoryPool::with_capacity(capacity)),
            _marker: PhantomData,
        }
    }
}

impl<T, A> ImplicitSplayTree<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitSplayTreeNode<T>>,
{
    fn node(&mut self, key: T::Key) -> ImplicitSplayTreeRoot<T> {
        BstRoot::from_data(
            ImplicitSplayTreeData {
                value: LazyMapElement::from_key(key),
                size: 1,
                rev: false,
            },
            self.allocator.deref_mut(),
        )
    }

    #[inline]
    fn splay<Seeker>(&mut self, seeker: Seeker) -> Option<Ordering>
    where
        Seeker: BstSeeker<Spec = ImplicitSplayTreeSpec<T>>,
    {
        let (ordering, root) = splay_operations::splay(self.root.take()?, seeker);
        self.root = Some(root);
        Some(ordering)
    }

    pub fn len(&self) -> usize {
        self.length
    }

    pub fn is_empty(&self) -> bool {
        self.length == 0
    }

    pub fn update<R>(&mut self, range: R, act: T::Act)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitSplayTreeSpec::update_act(root, &act);
        }
    }

    pub fn fold<R>(&mut self, range: R) -> T::Agg
    where
        R: RangeBounds<usize>,
    {
        let split = Split3::seek_by_size(&mut self.root, range);
        split
            .mid()
            .map(|node| node.into_data().value.agg.clone())
            .unwrap_or_else(T::agg_unit)
    }

    pub fn reverse<R>(&mut self, range: R)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitSplayTreeSpec::reverse(root);
        }
    }

    pub fn get(&mut self, index: usize) -> Option<&T::Key> {
        if index >= self.length {
            return None;
        }
        self.splay(SeekBySize::new(index));
        Some(&self.root.as_ref()?.reborrow().into_data().value.key)
    }

    pub fn modify<F>(&mut self, index: usize, f: F)
    where
        F: FnOnce(&T::Key) -> T::Key,
    {
        assert!(index < self.length);
        self.splay(SeekBySize::new(index));
        let mut root = self.root.as_mut().unwrap().borrow_datamut();
        ImplicitSplayTreeSpec::top_down(root.reborrow_datamut());
        {
            let data = root.data_mut();
            data.value.key = f(&data.value.key);
        }
        ImplicitSplayTreeSpec::bottom_up(root);
    }

    pub fn insert(&mut self, index: usize, key: T::Key) {
        assert!(index <= self.length);
        let mut node = self.node(key);
        if self.root.is_none() {
            self.root = Some(node);
        } else if index == self.length {
            self.splay(SeekBySize::new(index));
            unsafe { node.borrow_mut().left_mut().set(self.root.take().unwrap()) };
            ImplicitSplayTreeSpec::bottom_up(node.borrow_datamut());
            self.root = Some(node);
        } else {
            self.splay(SeekBySize::new(index));
            let mut root = self.root.take().unwrap();
            let left = unsafe { root.borrow_mut().left_mut().take() };
            if let Some(left) = left {
                unsafe { node.borrow_mut().left_mut().set(left) };
            }
            ImplicitSplayTreeSpec::bottom_up(root.borrow_datamut());
            unsafe { node.borrow_mut().right_mut().set(root) };
            ImplicitSplayTreeSpec::bottom_up(node.borrow_datamut());
            self.root = Some(node);
        }
        self.length += 1;
    }

    pub fn remove(&mut self, index: usize) -> Option<T::Key> {
        if index >= self.length {
            return None;
        }
        self.splay(SeekBySize::new(index));
        let mut node = self.root.take().unwrap();
        ImplicitSplayTreeSpec::top_down(node.borrow_datamut());
        let left = unsafe { node.borrow_mut().left_mut().take() };
        let right = unsafe { node.borrow_mut().right_mut().take() };
        self.root = ImplicitSplayTreeSpec::merge(left, right);
        self.length -= 1;
        let data = unsafe { node.into_dying().into_data(self.allocator.deref_mut()) };
        Some(data.value.key)
    }

crates/competitive/src/data_structure/implicit_treap.rs (line 253)

    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }
}

impl<T> ImplicitTreap<T>
where
    T: LazyMapMonoid,
{
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            root: None,
            length: 0,
            rng: Xorshift::new(),
            allocator: ManuallyDrop::new(MemoryPool::with_capacity(capacity)),
            _marker: PhantomData,
        }
    }
}

impl<T, A> ImplicitTreap<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>>,
{
    fn node(&mut self, key: T::Key) -> ImplicitTreapRoot<T> {
        BstRoot::from_data(
            ImplicitTreapData {
                priority: self.rng.rand64(),
                value: LazyMapElement::from_key(key),
                size: 1,
                rev: false,
            },
            self.allocator.deref_mut(),
        )
    }

    fn build<I>(&mut self, iter: I) -> (Option<ImplicitTreapRoot<T>>, usize)
    where
        I: IntoIterator<Item = T::Key>,
    {
        let mut stack = vec![];
        let mut len = 0;
        for key in iter {
            let mut cur = self.node(key).node;
            let mut left = None;
            unsafe {
                while stack
                    .last()
                    .is_some_and(|node: &NonNull<ImplicitTreapNode<T>>| {
                        node.as_ref().data.priority < cur.as_ref().data.priority
                    })
                {
                    left = stack.pop();
                }
                cur.as_mut().child[0] = left;
                if let Some(parent) = stack.last_mut() {
                    parent.as_mut().child[1] = Some(cur);
                }
            }
            stack.push(cur);
            len += 1;
        }
        let root = stack.first().copied().map(BstRoot::new);
        if let Some(mut root) = root {
            Self::build_bottom_up(root.borrow_datamut());
            (Some(root), len)
        } else {
            (None, len)
        }
    }

    fn build_bottom_up(mut node: BstDataMutRef<'_, ImplicitTreapSpec<T>>) {
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::build_bottom_up(left);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::build_bottom_up(right);
        }
        ImplicitTreapSpec::<T>::bottom_up(node);
    }

    pub fn len(&self) -> usize {
        self.length
    }

    pub fn is_empty(&self) -> bool {
        self.length == 0
    }

    pub fn update<R>(&mut self, range: R, x: T::Act)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitTreapSpec::<T>::update_act(root, &x);
        }
    }

    pub fn fold<R>(&mut self, range: R) -> T::Agg
    where
        R: RangeBounds<usize>,
    {
        let split = Split3::seek_by_size(&mut self.root, range);
        split
            .mid()
            .map(|node| node.into_data().value.agg.clone())
            .unwrap_or_else(T::agg_unit)
    }

    pub fn reverse<R>(&mut self, range: R)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitTreapSpec::<T>::reverse(root);
        }
    }

    pub fn get(&mut self, index: usize) -> Option<&T::Key> {
        if index >= self.length {
            return None;
        }
        let split = Split3::seek_by_size(&mut self.root, index..=index);
        let node = split.mid()?.node;
        drop(split);
        Some(unsafe { &(*node.as_ptr()).data.value.key })
    }

    pub fn modify<F>(&mut self, index: usize, f: F)
    where
        F: FnOnce(&T::Key) -> T::Key,
    {
        assert!(index < self.length);
        let mut split = Split3::seek_by_size(&mut self.root, index..=index);
        let mut node = split.mid_datamut().unwrap();
        ImplicitTreapSpec::<T>::top_down(node.reborrow_datamut());
        {
            let data = node.data_mut();
            data.value.key = f(&data.value.key);
        }
        ImplicitTreapSpec::<T>::bottom_up(node);
    }

    pub fn insert(&mut self, index: usize, x: T::Key) {
        assert!(index <= self.length);
        let node = self.node(x);
        if index == 0 {
            self.root = ImplicitTreapSpec::<T>::merge(Some(node), self.root.take());
        } else if index == self.length {
            self.root = ImplicitTreapSpec::<T>::merge(self.root.take(), Some(node));
        } else {
            let mut node = Some(node);
            let mut split = Split::new(&mut self.root, SeekBySize::new(index), EqualSide::Right);
            split.manually_merge(|left, right| {
                ImplicitTreapSpec::<T>::merge(
                    ImplicitTreapSpec::<T>::merge(left, node.take()),
                    right,
                )
            });
        }
        self.length += 1;
    }

    pub fn remove(&mut self, index: usize) -> Option<T::Key> {
        if index >= self.length {
            return None;
        }
        let mid;
        if index == 0 {
            let (left, right) = ImplicitTreapSpec::<T>::split(
                self.root.take(),
                SeekBySize::new(1),
                EqualSide::Right,
            );
            mid = left;
            self.root = right;
        } else if index + 1 == self.length {
            let (left, right) = ImplicitTreapSpec::<T>::split(
                self.root.take(),
                SeekBySize::new(index),
                EqualSide::Right,
            );
            mid = right;
            self.root = left;
        } else {
            let (left, rest) = ImplicitTreapSpec::<T>::split(
                self.root.take(),
                SeekBySize::new(index),
                EqualSide::Right,
            );
            let (middle, right) =
                ImplicitTreapSpec::<T>::split(rest, SeekBySize::new(1), EqualSide::Right);
            mid = middle;
            self.root = ImplicitTreapSpec::<T>::merge(left, right);
        }
        self.length -= 1;
        let mut node = mid.unwrap();
        ImplicitTreapSpec::<T>::top_down(node.borrow_datamut());
        let data = unsafe { node.into_dying().into_data(self.allocator.deref_mut()) };
        Some(data.value.key)
    }

crates/competitive/src/data_structure/splay_tree.rs (line 157)

    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }
}

impl<K, V> SplayTree<K, V> {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            root: None,
            length: 0,
            allocator: ManuallyDrop::new(MemoryPool::with_capacity(capacity)),
        }
    }
}

impl<K, V, A> SplayTree<K, V, A>
where
    A: Allocator<SplayTreeNode<K, V>>,
{
    #[inline]
    fn splay<Seeker>(&mut self, seeker: Seeker) -> Option<Ordering>
    where
        Seeker: BstSeeker<Spec = SplayTreeSpec<K, V>>,
    {
        let (ordering, root) = splay_operations::splay(self.root.take()?, seeker);
        self.root = Some(root);
        Some(ordering)
    }

    fn splay_by_key<Q>(&mut self, key: &Q) -> Option<Ordering>
    where
        K: Borrow<Q>,
        Q: Ord + ?Sized,
    {
        self.splay(SeekByKey::new(key))
    }

    fn splay_by_size(&mut self, index: usize) -> Option<Ordering> {
        self.splay(SeekBySize::new(index))
    }

    pub fn get<Q>(&mut self, key: &Q) -> Option<&V>
    where
        K: Borrow<Q>,
        Q: Ord + ?Sized,
    {
        self.get_key_value(key).map(|(_, value)| value)
    }

    pub fn get_key_value<Q>(&mut self, key: &Q) -> Option<(&K, &V)>
    where
        K: Borrow<Q>,
        Q: Ord + ?Sized,
    {
        matches!(self.splay_by_key(key)?, Ordering::Equal).then(|| {
            let data = self.root.as_ref().unwrap().reborrow().into_data();
            (&data.key, &data.value)
        })
    }

    pub fn get_key_value_at(&mut self, index: usize) -> Option<(&K, &V)> {
        if index >= self.length {
            return None;
        }
        self.splay_by_size(index);
        let data = self.root.as_ref()?.reborrow().into_data();
        Some((&data.key, &data.value))
    }

    pub fn insert(&mut self, key: K, value: V) -> Option<V>
    where
        K: Ord,
    {
        let ordering = self.splay_by_key(&key);
        if matches!(ordering, Some(Ordering::Equal)) {
            return Some(replace(
                &mut self
                    .root
                    .as_mut()
                    .unwrap()
                    .borrow_datamut()
                    .data_mut()
                    .value,
                value,
            ));
        }
        let mut node = BstRoot::from_data(
            SplayTreeData {
                key,
                value,
                size: 1,
            },
            self.allocator.deref_mut(),
        );
        if let Some(mut root) = self.root.take() {
            match ordering.unwrap() {
                Ordering::Greater => {
                    let left = unsafe { root.borrow_mut().left_mut().take() };
                    if let Some(left) = left {
                        unsafe { node.borrow_mut().left_mut().set(left) };
                    }
                    SplayTreeSpec::bottom_up(root.borrow_datamut());
                    unsafe { node.borrow_mut().right_mut().set(root) };
                }
                Ordering::Less => {
                    let right = unsafe { root.borrow_mut().right_mut().take() };
                    if let Some(right) = right {
                        unsafe { node.borrow_mut().right_mut().set(right) };
                    }
                    SplayTreeSpec::bottom_up(root.borrow_datamut());
                    unsafe { node.borrow_mut().left_mut().set(root) };
                }
                Ordering::Equal => unreachable!(),
            }
            SplayTreeSpec::bottom_up(node.borrow_datamut());
        }
        self.root = Some(node);
        self.length += 1;
        None
    }

    pub fn remove<Q>(&mut self, key: &Q) -> Option<V>
    where
        K: Borrow<Q>,
        Q: Ord + ?Sized,
    {
        if !matches!(self.splay_by_key(key)?, Ordering::Equal) {
            return None;
        }
        Some(self.remove_root().1)
    }

    pub fn remove_at(&mut self, index: usize) -> Option<(K, V)> {
        if index >= self.length {
            return None;
        }
        self.splay_by_size(index);
        Some(self.remove_root())
    }

    fn remove_root(&mut self) -> (K, V) {
        let mut node = self.root.take().unwrap();
        let left = unsafe { node.borrow_mut().left_mut().take() };
        let right = unsafe { node.borrow_mut().right_mut().take() };
        self.root = SplayTreeSpec::merge(left, right);
        self.length -= 1;
        let data = unsafe { node.into_dying().into_data(self.allocator.deref_mut()) };
        (data.key, data.value)
    }

crates/competitive/src/data_structure/treap.rs (line 268)

    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }
}

impl<M, L> Treap<M, L>
where
    M: MonoidAct<Key: Ord>,
    L: LazyMapMonoid,
{
    pub fn new() -> Self {
        Self::default()
    }
}

impl<M, L, A> Treap<M, L, A>
where
    M: MonoidAct<Key: Ord>,
    L: LazyMapMonoid,
    A: Allocator<TreapNode<M, L>>,
{
    pub fn len(&self) -> usize {
        self.node_id_manager.len()
    }

    pub fn is_empty(&self) -> bool {
        self.node_id_manager.is_empty()
    }

    pub fn clear(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            self.node_id_manager.clear();
        }
    }

    pub fn get(&mut self, node_id: BstNodeId<TreapSpec<M, L>>) -> Option<(&M::Key, &L::Key)> {
        if !self.node_id_manager.contains(&node_id) {
            return None;
        }
        unsafe {
            WithParent::resolve_top_down::<TreapSpec<M, L>>(
                node_id.reborrow_datamut(&mut self.root),
            );
            let data = node_id.reborrow(&self.root).into_data();
            Some((&data.key.key, &data.value.key))
        }
    }

    pub fn change(
        &mut self,
        node_id: BstNodeId<TreapSpec<M, L>>,
        f: impl FnOnce(&mut L::Key),
    ) -> bool {
        if !self.node_id_manager.contains(&node_id) {
            return false;
        }
        unsafe {
            WithParent::resolve_top_down::<TreapSpec<M, L>>(
                node_id.reborrow_datamut(&mut self.root),
            );
            let data = node_id.reborrow_datamut(&mut self.root).into_data_mut();
            f(&mut data.value.key);
            WithParent::resolve_bottom_up::<TreapSpec<M, L>>(
                node_id.reborrow_datamut(&mut self.root),
            );
        }
        true
    }

    pub fn change_key_value(
        &mut self,
        node_id: BstNodeId<TreapSpec<M, L>>,
        f: impl FnOnce(&mut M::Key, &mut L::Key),
    ) -> bool {
        if !self.node_id_manager.contains(&node_id) {
            return false;
        }
        unsafe {
            WithParent::resolve_top_down::<TreapSpec<M, L>>(
                node_id.reborrow_datamut(&mut self.root),
            );
            let mut node = if WithParent::is_root(node_id.reborrow(&self.root)) {
                WithParent::remove_root(&mut self.root).unwrap_unchecked()
            } else {
                WithParent::remove_not_root(node_id.reborrow_mut(&mut self.root))
            };
            let data = node.borrow_datamut().into_data_mut();
            f(&mut data.key.key, &mut data.value.key);
            self.root = TreapSpec::merge_ordered(self.root.take(), Some(node));
            true
        }
    }

    pub fn insert(&mut self, key: M::Key, value: L::Key) -> BstNodeId<TreapSpec<M, L>> {
        let (left, right) =
            TreapSpec::split(self.root.take(), SeekByKey::new(&key), EqualSide::Right);
        let data = TreapData {
            priority: self.rng.rand64(),
            key: MonoidActElement::from_key(key),
            value: LazyMapElement::from_key(value),
        };
        let node = BstRoot::from_data(data, self.allocator.deref_mut());
        let node_id = self.node_id_manager.register(&node);
        self.root = TreapSpec::merge(TreapSpec::merge(left, Some(node)), right);
        node_id
    }

    pub fn remove(&mut self, node_id: BstNodeId<TreapSpec<M, L>>) -> Option<(M::Key, L::Key)> {
        if !self.node_id_manager.contains(&node_id) {
            return None;
        }
        unsafe {
            WithParent::resolve_top_down::<TreapSpec<M, L>>(
                node_id.reborrow_datamut(&mut self.root),
            );
            let node = if WithParent::is_root(node_id.reborrow(&self.root)) {
                WithParent::remove_root(&mut self.root).unwrap_unchecked()
            } else {
                WithParent::remove_not_root(node_id.reborrow_mut(&mut self.root))
            };
            self.node_id_manager.unregister(node_id);
            let data = node.into_dying().into_data(self.allocator.deref_mut());
            Some((data.key.key, data.value.key))
        }
    }

impl<'a, Spec> BstNodeRef<Immut<'a>, Spec>

where Spec: BstSpec<Parent: 'a, Data: 'a>,

pub fn into_data(self) -> &'a Spec::Data

Examples found in repository

crates/competitive/src/data_structure/binary_search_tree/seeker.rs (line 93)

    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        node.reborrow()
            .into_data()
            .bst_data()
            .borrow()
            .cmp(self.key)
    }
}

pub struct SeekBySize<Spec> {
    index: usize,
    _marker: PhantomData<fn() -> Spec>,
}

impl<Spec> SeekBySize<Spec> {
    pub fn new(index: usize) -> Self {
        Self {
            index,
            _marker: PhantomData,
        }
    }
}

impl<Spec> BstSeeker for SeekBySize<Spec>
where
    Spec: BstSpec<Data: BstDataAccess<data::marker::Size, Value = usize>>,
{
    type Spec = Spec;

    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        let lsize = node
            .reborrow()
            .left()
            .descend()
            .map(|l| *l.into_data().bst_data())
            .unwrap_or_default();
        let ord = lsize.cmp(&self.index);
        if matches!(ord, Ordering::Less) {
            self.index -= lsize + 1;
        }
        ord
    }
}

pub struct SeekByAccCond<Spec, L, F>
where
    L: LazyMapMonoid,
{
    acc: L::Agg,
    f: F,
    _marker: PhantomData<fn() -> (Spec, L)>,
}

impl<Spec, L, F> SeekByAccCond<Spec, L, F>
where
    L: LazyMapMonoid,
    F: FnMut(&L::Agg) -> bool,
{
    pub fn new(f: F) -> Self {
        Self {
            acc: L::agg_unit(),
            f,
            _marker: PhantomData,
        }
    }
}

impl<Spec, L, F> BstSeeker for SeekByAccCond<Spec, L, F>
where
    Spec: BstSpec<Data: BstDataAccess<data::marker::LazyMap, Value = LazyMapElement<L>>>,
    L: LazyMapMonoid,
    F: FnMut(&L::Agg) -> bool,
{
    type Spec = Spec;

    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        if let Ok(left) = node.reborrow().left().descend() {
            let left_agg = &left.into_data().bst_data().agg;
            let nagg = L::agg_operate(&self.acc, left_agg);
            if (self.f)(&nagg) {
                return Ordering::Greater;
            }
            let nagg = L::agg_operate(
                &nagg,
                &L::single_agg(&node.reborrow().into_data().bst_data().key),
            );
            if (self.f)(&nagg) {
                Ordering::Equal
            } else {
                self.acc = nagg;
                Ordering::Less
            }
        } else {
            let nagg = L::agg_operate(
                &self.acc,
                &L::single_agg(&node.reborrow().into_data().bst_data().key),
            );
            if (self.f)(&nagg) {
                Ordering::Equal
            } else {
                self.acc = nagg;
                Ordering::Less
            }
        }
    }
}

pub struct SeekByRaccCond<Spec, L, F>
where
    L: LazyMapMonoid,
{
    acc: L::Agg,
    f: F,
    _marker: PhantomData<fn() -> (Spec, L)>,
}

impl<Spec, L, F> SeekByRaccCond<Spec, L, F>
where
    L: LazyMapMonoid,
    F: FnMut(&L::Agg) -> bool,
{
    pub fn new(f: F) -> Self {
        Self {
            acc: L::agg_unit(),
            f,
            _marker: PhantomData,
        }
    }
}

impl<Spec, L, F> BstSeeker for SeekByRaccCond<Spec, L, F>
where
    Spec: BstSpec<Data: BstDataAccess<data::marker::LazyMap, Value = LazyMapElement<L>>>,
    L: LazyMapMonoid,
    F: FnMut(&L::Agg) -> bool,
{
    type Spec = Spec;

    fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering {
        if let Ok(right) = node.reborrow().right().descend() {
            let right_agg = &right.into_data().bst_data().agg;
            let nagg = L::agg_operate(right_agg, &self.acc);
            if (self.f)(&nagg) {
                return Ordering::Less;
            }
            let nagg = L::agg_operate(
                &L::single_agg(&node.reborrow().into_data().bst_data().key),
                &nagg,
            );
            if (self.f)(&nagg) {
                Ordering::Equal
            } else {
                self.acc = nagg;
                Ordering::Greater
            }
        } else {
            let nagg = L::agg_operate(
                &L::single_agg(&node.reborrow().into_data().bst_data().key),
                &self.acc,
            );
            if (self.f)(&nagg) {
                Ordering::Equal
            } else {
                self.acc = nagg;
                Ordering::Greater
            }
        }
    }

crates/competitive/src/data_structure/splay_tree.rs (line 83)

    fn bottom_up(mut node: BstDataMutRef<'_, Self>) {
        let left = node
            .reborrow()
            .left()
            .descend()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        let right = node
            .reborrow()
            .right()
            .descend()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        node.data_mut().size = left + right + 1;
    }

    #[inline]
    fn merge(
        left: Option<SplayTreeRoot<K, V>>,
        right: Option<SplayTreeRoot<K, V>>,
    ) -> Option<SplayTreeRoot<K, V>> {
        splay_operations::merge(left, right)
    }

    #[inline]
    fn split<Seeker>(
        node: Option<SplayTreeRoot<K, V>>,
        seeker: Seeker,
        equal_side: EqualSide,
    ) -> (Option<SplayTreeRoot<K, V>>, Option<SplayTreeRoot<K, V>>)
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        splay_operations::split(node, seeker, equal_side)
    }
}

pub struct SplayTree<K, V, A = MemoryPool<SplayTreeNode<K, V>>>
where
    A: Allocator<SplayTreeNode<K, V>>,
{
    root: Option<SplayTreeRoot<K, V>>,
    length: usize,
    allocator: ManuallyDrop<A>,
}

impl<K, V, A> Debug for SplayTree<K, V, A>
where
    K: Debug,
    V: Debug,
    A: Allocator<SplayTreeNode<K, V>>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("SplayTree")
            .field("length", &self.length)
            .finish_non_exhaustive()
    }
}

impl<K, V, A> Default for SplayTree<K, V, A>
where
    A: Allocator<SplayTreeNode<K, V>> + Default,
{
    fn default() -> Self {
        Self {
            root: None,
            length: 0,
            allocator: ManuallyDrop::new(A::default()),
        }
    }
}

impl<K, V, A> Drop for SplayTree<K, V, A>
where
    A: Allocator<SplayTreeNode<K, V>>,
{
    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }
}

impl<K, V> SplayTree<K, V> {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            root: None,
            length: 0,
            allocator: ManuallyDrop::new(MemoryPool::with_capacity(capacity)),
        }
    }
}

impl<K, V, A> SplayTree<K, V, A>
where
    A: Allocator<SplayTreeNode<K, V>>,
{
    #[inline]
    fn splay<Seeker>(&mut self, seeker: Seeker) -> Option<Ordering>
    where
        Seeker: BstSeeker<Spec = SplayTreeSpec<K, V>>,
    {
        let (ordering, root) = splay_operations::splay(self.root.take()?, seeker);
        self.root = Some(root);
        Some(ordering)
    }

    fn splay_by_key<Q>(&mut self, key: &Q) -> Option<Ordering>
    where
        K: Borrow<Q>,
        Q: Ord + ?Sized,
    {
        self.splay(SeekByKey::new(key))
    }

    fn splay_by_size(&mut self, index: usize) -> Option<Ordering> {
        self.splay(SeekBySize::new(index))
    }

    pub fn get<Q>(&mut self, key: &Q) -> Option<&V>
    where
        K: Borrow<Q>,
        Q: Ord + ?Sized,
    {
        self.get_key_value(key).map(|(_, value)| value)
    }

    pub fn get_key_value<Q>(&mut self, key: &Q) -> Option<(&K, &V)>
    where
        K: Borrow<Q>,
        Q: Ord + ?Sized,
    {
        matches!(self.splay_by_key(key)?, Ordering::Equal).then(|| {
            let data = self.root.as_ref().unwrap().reborrow().into_data();
            (&data.key, &data.value)
        })
    }

    pub fn get_key_value_at(&mut self, index: usize) -> Option<(&K, &V)> {
        if index >= self.length {
            return None;
        }
        self.splay_by_size(index);
        let data = self.root.as_ref()?.reborrow().into_data();
        Some((&data.key, &data.value))
    }

    pub fn insert(&mut self, key: K, value: V) -> Option<V>
    where
        K: Ord,
    {
        let ordering = self.splay_by_key(&key);
        if matches!(ordering, Some(Ordering::Equal)) {
            return Some(replace(
                &mut self
                    .root
                    .as_mut()
                    .unwrap()
                    .borrow_datamut()
                    .data_mut()
                    .value,
                value,
            ));
        }
        let mut node = BstRoot::from_data(
            SplayTreeData {
                key,
                value,
                size: 1,
            },
            self.allocator.deref_mut(),
        );
        if let Some(mut root) = self.root.take() {
            match ordering.unwrap() {
                Ordering::Greater => {
                    let left = unsafe { root.borrow_mut().left_mut().take() };
                    if let Some(left) = left {
                        unsafe { node.borrow_mut().left_mut().set(left) };
                    }
                    SplayTreeSpec::bottom_up(root.borrow_datamut());
                    unsafe { node.borrow_mut().right_mut().set(root) };
                }
                Ordering::Less => {
                    let right = unsafe { root.borrow_mut().right_mut().take() };
                    if let Some(right) = right {
                        unsafe { node.borrow_mut().right_mut().set(right) };
                    }
                    SplayTreeSpec::bottom_up(root.borrow_datamut());
                    unsafe { node.borrow_mut().left_mut().set(root) };
                }
                Ordering::Equal => unreachable!(),
            }
            SplayTreeSpec::bottom_up(node.borrow_datamut());
        }
        self.root = Some(node);
        self.length += 1;
        None
    }

    pub fn remove<Q>(&mut self, key: &Q) -> Option<V>
    where
        K: Borrow<Q>,
        Q: Ord + ?Sized,
    {
        if !matches!(self.splay_by_key(key)?, Ordering::Equal) {
            return None;
        }
        Some(self.remove_root().1)
    }

    pub fn remove_at(&mut self, index: usize) -> Option<(K, V)> {
        if index >= self.length {
            return None;
        }
        self.splay_by_size(index);
        Some(self.remove_root())
    }

    fn remove_root(&mut self) -> (K, V) {
        let mut node = self.root.take().unwrap();
        let left = unsafe { node.borrow_mut().left_mut().take() };
        let right = unsafe { node.borrow_mut().right_mut().take() };
        self.root = SplayTreeSpec::merge(left, right);
        self.length -= 1;
        let data = unsafe { node.into_dying().into_data(self.allocator.deref_mut()) };
        (data.key, data.value)
    }

    pub fn len(&self) -> usize {
        self.length
    }

    pub fn is_empty(&self) -> bool {
        self.length == 0
    }

    pub fn iter(&mut self) -> Iter<'_, K, V> {
        Iter::new(Split3::seek_by_size(&mut self.root, ..))
    }

    pub fn range<Q, R>(&mut self, range: R) -> Iter<'_, K, V>
    where
        K: Borrow<Q>,
        Q: Ord + ?Sized,
        R: RangeBounds<Q>,
    {
        Iter::new(Split3::seek_by_key(&mut self.root, range))
    }

    pub fn range_at<R>(&mut self, range: R) -> Iter<'_, K, V>
    where
        R: RangeBounds<usize>,
    {
        Iter::new(Split3::seek_by_size(&mut self.root, range))
    }
}

pub struct Iter<'a, K, V> {
    split: Split3<'a, SplayTreeSpec<K, V>>,
    front: Vec<NonNull<SplayTreeNode<K, V>>>,
    back: Vec<NonNull<SplayTreeNode<K, V>>>,
    remaining: usize,
}

impl<K, V> Debug for Iter<'_, K, V> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Iter")
            .field("remaining", &self.remaining)
            .finish_non_exhaustive()
    }
}

impl<'a, K, V> Iter<'a, K, V> {
    fn new(split: Split3<'a, SplayTreeSpec<K, V>>) -> Self {
        let remaining = split
            .mid()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        let mut iter = Self {
            split,
            front: vec![],
            back: vec![],
            remaining,
        };
        if let Some(root) = iter.split.mid() {
            Self::push_left(root.node, &mut iter.front);
            Self::push_right(root.node, &mut iter.back);
        }
        iter
    }

crates/competitive/src/data_structure/implicit_splay_tree.rs (line 88)

    fn update_act(mut node: BstDataMutRef<'_, Self>, act: &T::Act) {
        if T::is_act_unit(act) {
            return;
        }
        T::act_operate_assign(&mut node.data_mut().value.act, act);
        node.data_mut().value.key = T::act_key(&node.reborrow().into_data().value.key, act);
        if let Some(agg) = T::act_agg(&node.reborrow().into_data().value.agg, act) {
            node.data_mut().value.agg = agg;
        } else {
            Self::top_down(node.reborrow_datamut());
            Self::bottom_up(node);
        }
    }

    fn reverse(mut node: BstDataMutRef<'_, Self>) {
        node.swap_children();
        let data = node.data_mut();
        T::toggle(&mut data.value.agg);
        data.rev ^= true;
    }
}

impl<T> BstSpec for ImplicitSplayTreeSpec<T>
where
    T: LazyMapMonoid,
{
    type Parent = WithNoParent<Self::Data>;
    type Data = ImplicitSplayTreeData<T>;

    fn top_down(mut node: BstDataMutRef<'_, Self>) {
        if !T::is_act_unit(&node.reborrow().into_data().value.act) {
            let act = replace(&mut node.data_mut().value.act, T::act_unit());
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::update_act(left, &act);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::update_act(right, &act);
            }
        }
        if node.reborrow().into_data().rev {
            node.data_mut().rev = false;
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::reverse(left);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::reverse(right);
            }
        }
    }

    fn bottom_up(mut node: BstDataMutRef<'_, Self>) {
        let mut agg = T::single_agg(&node.reborrow().into_data().value.key);
        let mut size = 1;
        if let Ok(left) = node.reborrow().left().descend() {
            let data = left.into_data();
            agg = T::agg_operate(&data.value.agg, &agg);
            size += data.size;
        }
        if let Ok(right) = node.reborrow().right().descend() {
            let data = right.into_data();
            agg = T::agg_operate(&agg, &data.value.agg);
            size += data.size;
        }
        let data = node.data_mut();
        data.value.agg = agg;
        data.size = size;
    }

    fn merge(
        left: Option<ImplicitSplayTreeRoot<T>>,
        right: Option<ImplicitSplayTreeRoot<T>>,
    ) -> Option<ImplicitSplayTreeRoot<T>> {
        splay_operations::merge(left, right)
    }

    fn split<Seeker>(
        node: Option<ImplicitSplayTreeRoot<T>>,
        seeker: Seeker,
        equal_side: EqualSide,
    ) -> (
        Option<ImplicitSplayTreeRoot<T>>,
        Option<ImplicitSplayTreeRoot<T>>,
    )
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        splay_operations::split(node, seeker, equal_side)
    }
}

pub struct ImplicitSplayTree<T, A = MemoryPool<ImplicitSplayTreeNode<T>>>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitSplayTreeNode<T>>,
{
    root: Option<ImplicitSplayTreeRoot<T>>,
    length: usize,
    allocator: ManuallyDrop<A>,
    _marker: PhantomData<fn() -> T>,
}

impl<T, A> Default for ImplicitSplayTree<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitSplayTreeNode<T>> + Default,
{
    fn default() -> Self {
        Self {
            root: None,
            length: 0,
            allocator: ManuallyDrop::new(A::default()),
            _marker: PhantomData,
        }
    }
}

impl<T, A> Drop for ImplicitSplayTree<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitSplayTreeNode<T>>,
{
    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }
}

impl<T> ImplicitSplayTree<T>
where
    T: LazyMapMonoid,
{
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            root: None,
            length: 0,
            allocator: ManuallyDrop::new(MemoryPool::with_capacity(capacity)),
            _marker: PhantomData,
        }
    }
}

impl<T, A> ImplicitSplayTree<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitSplayTreeNode<T>>,
{
    fn node(&mut self, key: T::Key) -> ImplicitSplayTreeRoot<T> {
        BstRoot::from_data(
            ImplicitSplayTreeData {
                value: LazyMapElement::from_key(key),
                size: 1,
                rev: false,
            },
            self.allocator.deref_mut(),
        )
    }

    #[inline]
    fn splay<Seeker>(&mut self, seeker: Seeker) -> Option<Ordering>
    where
        Seeker: BstSeeker<Spec = ImplicitSplayTreeSpec<T>>,
    {
        let (ordering, root) = splay_operations::splay(self.root.take()?, seeker);
        self.root = Some(root);
        Some(ordering)
    }

    pub fn len(&self) -> usize {
        self.length
    }

    pub fn is_empty(&self) -> bool {
        self.length == 0
    }

    pub fn update<R>(&mut self, range: R, act: T::Act)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitSplayTreeSpec::update_act(root, &act);
        }
    }

    pub fn fold<R>(&mut self, range: R) -> T::Agg
    where
        R: RangeBounds<usize>,
    {
        let split = Split3::seek_by_size(&mut self.root, range);
        split
            .mid()
            .map(|node| node.into_data().value.agg.clone())
            .unwrap_or_else(T::agg_unit)
    }

    pub fn reverse<R>(&mut self, range: R)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitSplayTreeSpec::reverse(root);
        }
    }

    pub fn get(&mut self, index: usize) -> Option<&T::Key> {
        if index >= self.length {
            return None;
        }
        self.splay(SeekBySize::new(index));
        Some(&self.root.as_ref()?.reborrow().into_data().value.key)
    }

    pub fn modify<F>(&mut self, index: usize, f: F)
    where
        F: FnOnce(&T::Key) -> T::Key,
    {
        assert!(index < self.length);
        self.splay(SeekBySize::new(index));
        let mut root = self.root.as_mut().unwrap().borrow_datamut();
        ImplicitSplayTreeSpec::top_down(root.reborrow_datamut());
        {
            let data = root.data_mut();
            data.value.key = f(&data.value.key);
        }
        ImplicitSplayTreeSpec::bottom_up(root);
    }

    pub fn insert(&mut self, index: usize, key: T::Key) {
        assert!(index <= self.length);
        let mut node = self.node(key);
        if self.root.is_none() {
            self.root = Some(node);
        } else if index == self.length {
            self.splay(SeekBySize::new(index));
            unsafe { node.borrow_mut().left_mut().set(self.root.take().unwrap()) };
            ImplicitSplayTreeSpec::bottom_up(node.borrow_datamut());
            self.root = Some(node);
        } else {
            self.splay(SeekBySize::new(index));
            let mut root = self.root.take().unwrap();
            let left = unsafe { root.borrow_mut().left_mut().take() };
            if let Some(left) = left {
                unsafe { node.borrow_mut().left_mut().set(left) };
            }
            ImplicitSplayTreeSpec::bottom_up(root.borrow_datamut());
            unsafe { node.borrow_mut().right_mut().set(root) };
            ImplicitSplayTreeSpec::bottom_up(node.borrow_datamut());
            self.root = Some(node);
        }
        self.length += 1;
    }

    pub fn remove(&mut self, index: usize) -> Option<T::Key> {
        if index >= self.length {
            return None;
        }
        self.splay(SeekBySize::new(index));
        let mut node = self.root.take().unwrap();
        ImplicitSplayTreeSpec::top_down(node.borrow_datamut());
        let left = unsafe { node.borrow_mut().left_mut().take() };
        let right = unsafe { node.borrow_mut().right_mut().take() };
        self.root = ImplicitSplayTreeSpec::merge(left, right);
        self.length -= 1;
        let data = unsafe { node.into_dying().into_data(self.allocator.deref_mut()) };
        Some(data.value.key)
    }

    pub fn partition_point_acc<F>(&mut self, left: usize, mut pred: F) -> usize
    where
        F: FnMut(&T::Agg) -> bool,
    {
        let mut split3 = Split3::seek_by_size(&mut self.root, left..);
        let front_size = split3
            .left()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        let split = split3.split_mid(SeekByAccCond::new(|acc| !pred(acc)), EqualSide::Right);
        let index = split
            .left()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        front_size + index
    }

    pub fn rpartition_point_acc<F>(&mut self, right: usize, mut pred: F) -> usize
    where
        F: FnMut(&T::Agg) -> bool,
    {
        let mut split3 = Split3::seek_by_size(&mut self.root, ..right);
        let split = split3.split_mid(SeekByRaccCond::new(|acc| !pred(acc)), EqualSide::Left);
        split
            .left()
            .map(|node| node.into_data().size)
            .unwrap_or_default()
    }

crates/competitive/src/data_structure/implicit_treap.rs (line 89)

    fn update_act(mut node: BstDataMutRef<'_, Self>, act: &T::Act) {
        if T::is_act_unit(act) {
            return;
        }
        T::act_operate_assign(&mut node.data_mut().value.act, act);
        node.data_mut().value.key = T::act_key(&node.reborrow().into_data().value.key, act);
        if let Some(agg) = T::act_agg(&node.reborrow().into_data().value.agg, act) {
            node.data_mut().value.agg = agg;
        } else {
            Self::top_down(node.reborrow_datamut());
            Self::bottom_up(node);
        }
    }

    fn reverse(mut node: BstDataMutRef<'_, Self>) {
        node.swap_children();
        let data = node.data_mut();
        T::toggle(&mut data.value.agg);
        data.rev ^= true;
    }
}

impl<T> BstSpec for ImplicitTreapSpec<T>
where
    T: LazyMapMonoid,
{
    type Parent = WithNoParent<Self::Data>;
    type Data = ImplicitTreapData<T>;

    fn top_down(mut node: BstDataMutRef<'_, Self>) {
        if !T::is_act_unit(&node.reborrow().into_data().value.act) {
            let act = replace(&mut node.data_mut().value.act, T::act_unit());
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::update_act(left, &act);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::update_act(right, &act);
            }
        }
        if node.reborrow().into_data().rev {
            node.data_mut().rev = false;
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::reverse(left);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::reverse(right);
            }
        }
    }

    fn bottom_up(mut node: BstDataMutRef<'_, Self>) {
        let mut agg = T::single_agg(&node.reborrow().into_data().value.key);
        let mut size = 1;
        if let Ok(left) = node.reborrow().left().descend() {
            let data = left.into_data();
            agg = T::agg_operate(&data.value.agg, &agg);
            size += data.size;
        }
        if let Ok(right) = node.reborrow().right().descend() {
            let data = right.into_data();
            agg = T::agg_operate(&agg, &data.value.agg);
            size += data.size;
        }
        let data = node.data_mut();
        data.value.agg = agg;
        data.size = size;
    }

    fn merge(
        left: Option<ImplicitTreapRoot<T>>,
        right: Option<ImplicitTreapRoot<T>>,
    ) -> Option<ImplicitTreapRoot<T>> {
        match (left, right) {
            (None, None) => None,
            (None, Some(node)) | (Some(node), None) => Some(node),
            (Some(mut left), Some(mut right)) => unsafe {
                if left.reborrow().into_data().priority > right.reborrow().into_data().priority {
                    Self::top_down(left.borrow_datamut());
                    let lr = left.borrow_mut().right().take();
                    let lr = Self::merge(lr, Some(right)).unwrap_unchecked();
                    left.borrow_mut().right().set(lr);
                    Self::bottom_up(left.borrow_datamut());
                    Some(left)
                } else {
                    Self::top_down(right.borrow_datamut());
                    let rl = right.borrow_mut().left().take();
                    let rl = Self::merge(Some(left), rl).unwrap_unchecked();
                    right.borrow_mut().left().set(rl);
                    Self::bottom_up(right.borrow_datamut());
                    Some(right)
                }
            },
        }
    }

    fn split<Seeker>(
        node: Option<ImplicitTreapRoot<T>>,
        mut seeker: Seeker,
        equal_side: EqualSide,
    ) -> (Option<ImplicitTreapRoot<T>>, Option<ImplicitTreapRoot<T>>)
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        match node {
            None => (None, None),
            Some(mut node) => {
                Self::top_down(node.borrow_datamut());
                if equal_side.goes_left(seeker.bst_seek(node.reborrow())) {
                    unsafe {
                        let right = node.borrow_mut().right().take();
                        let (l, r) = Self::split(right, seeker, equal_side);
                        if let Some(l) = l {
                            node.borrow_mut().right().set(l);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (Some(node), r)
                    }
                } else {
                    unsafe {
                        let left = node.borrow_mut().left().take();
                        let (l, r) = Self::split(left, seeker, equal_side);
                        if let Some(r) = r {
                            node.borrow_mut().left().set(r);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (l, Some(node))
                    }
                }
            }
        }
    }
}

pub struct ImplicitTreap<T, A = MemoryPool<ImplicitTreapNode<T>>>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>>,
{
    root: Option<ImplicitTreapRoot<T>>,
    length: usize,
    rng: Xorshift,
    allocator: ManuallyDrop<A>,
    _marker: PhantomData<fn() -> T>,
}

impl<T, A> Default for ImplicitTreap<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>> + Default,
{
    fn default() -> Self {
        Self {
            root: None,
            length: 0,
            rng: Xorshift::new(),
            allocator: ManuallyDrop::new(A::default()),
            _marker: PhantomData,
        }
    }
}

impl<T, A> Drop for ImplicitTreap<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>>,
{
    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }
}

impl<T> ImplicitTreap<T>
where
    T: LazyMapMonoid,
{
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            root: None,
            length: 0,
            rng: Xorshift::new(),
            allocator: ManuallyDrop::new(MemoryPool::with_capacity(capacity)),
            _marker: PhantomData,
        }
    }
}

impl<T, A> ImplicitTreap<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>>,
{
    fn node(&mut self, key: T::Key) -> ImplicitTreapRoot<T> {
        BstRoot::from_data(
            ImplicitTreapData {
                priority: self.rng.rand64(),
                value: LazyMapElement::from_key(key),
                size: 1,
                rev: false,
            },
            self.allocator.deref_mut(),
        )
    }

    fn build<I>(&mut self, iter: I) -> (Option<ImplicitTreapRoot<T>>, usize)
    where
        I: IntoIterator<Item = T::Key>,
    {
        let mut stack = vec![];
        let mut len = 0;
        for key in iter {
            let mut cur = self.node(key).node;
            let mut left = None;
            unsafe {
                while stack
                    .last()
                    .is_some_and(|node: &NonNull<ImplicitTreapNode<T>>| {
                        node.as_ref().data.priority < cur.as_ref().data.priority
                    })
                {
                    left = stack.pop();
                }
                cur.as_mut().child[0] = left;
                if let Some(parent) = stack.last_mut() {
                    parent.as_mut().child[1] = Some(cur);
                }
            }
            stack.push(cur);
            len += 1;
        }
        let root = stack.first().copied().map(BstRoot::new);
        if let Some(mut root) = root {
            Self::build_bottom_up(root.borrow_datamut());
            (Some(root), len)
        } else {
            (None, len)
        }
    }

    fn build_bottom_up(mut node: BstDataMutRef<'_, ImplicitTreapSpec<T>>) {
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::build_bottom_up(left);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::build_bottom_up(right);
        }
        ImplicitTreapSpec::<T>::bottom_up(node);
    }

    pub fn len(&self) -> usize {
        self.length
    }

    pub fn is_empty(&self) -> bool {
        self.length == 0
    }

    pub fn update<R>(&mut self, range: R, x: T::Act)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitTreapSpec::<T>::update_act(root, &x);
        }
    }

    pub fn fold<R>(&mut self, range: R) -> T::Agg
    where
        R: RangeBounds<usize>,
    {
        let split = Split3::seek_by_size(&mut self.root, range);
        split
            .mid()
            .map(|node| node.into_data().value.agg.clone())
            .unwrap_or_else(T::agg_unit)
    }

    pub fn reverse<R>(&mut self, range: R)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitTreapSpec::<T>::reverse(root);
        }
    }

    pub fn get(&mut self, index: usize) -> Option<&T::Key> {
        if index >= self.length {
            return None;
        }
        let split = Split3::seek_by_size(&mut self.root, index..=index);
        let node = split.mid()?.node;
        drop(split);
        Some(unsafe { &(*node.as_ptr()).data.value.key })
    }

    pub fn modify<F>(&mut self, index: usize, f: F)
    where
        F: FnOnce(&T::Key) -> T::Key,
    {
        assert!(index < self.length);
        let mut split = Split3::seek_by_size(&mut self.root, index..=index);
        let mut node = split.mid_datamut().unwrap();
        ImplicitTreapSpec::<T>::top_down(node.reborrow_datamut());
        {
            let data = node.data_mut();
            data.value.key = f(&data.value.key);
        }
        ImplicitTreapSpec::<T>::bottom_up(node);
    }

    pub fn insert(&mut self, index: usize, x: T::Key) {
        assert!(index <= self.length);
        let node = self.node(x);
        if index == 0 {
            self.root = ImplicitTreapSpec::<T>::merge(Some(node), self.root.take());
        } else if index == self.length {
            self.root = ImplicitTreapSpec::<T>::merge(self.root.take(), Some(node));
        } else {
            let mut node = Some(node);
            let mut split = Split::new(&mut self.root, SeekBySize::new(index), EqualSide::Right);
            split.manually_merge(|left, right| {
                ImplicitTreapSpec::<T>::merge(
                    ImplicitTreapSpec::<T>::merge(left, node.take()),
                    right,
                )
            });
        }
        self.length += 1;
    }

    pub fn remove(&mut self, index: usize) -> Option<T::Key> {
        if index >= self.length {
            return None;
        }
        let mid;
        if index == 0 {
            let (left, right) = ImplicitTreapSpec::<T>::split(
                self.root.take(),
                SeekBySize::new(1),
                EqualSide::Right,
            );
            mid = left;
            self.root = right;
        } else if index + 1 == self.length {
            let (left, right) = ImplicitTreapSpec::<T>::split(
                self.root.take(),
                SeekBySize::new(index),
                EqualSide::Right,
            );
            mid = right;
            self.root = left;
        } else {
            let (left, rest) = ImplicitTreapSpec::<T>::split(
                self.root.take(),
                SeekBySize::new(index),
                EqualSide::Right,
            );
            let (middle, right) =
                ImplicitTreapSpec::<T>::split(rest, SeekBySize::new(1), EqualSide::Right);
            mid = middle;
            self.root = ImplicitTreapSpec::<T>::merge(left, right);
        }
        self.length -= 1;
        let mut node = mid.unwrap();
        ImplicitTreapSpec::<T>::top_down(node.borrow_datamut());
        let data = unsafe { node.into_dying().into_data(self.allocator.deref_mut()) };
        Some(data.value.key)
    }

    pub fn partition_point_acc<F>(&mut self, left: usize, mut pred: F) -> usize
    where
        F: FnMut(&T::Agg) -> bool,
    {
        let mut split3 = Split3::seek_by_size(&mut self.root, left..);
        let front_size = split3
            .left()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        let split = split3.split_mid(SeekByAccCond::new(|acc| !pred(acc)), EqualSide::Right);
        let index = split
            .left()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        front_size + index
    }

    pub fn rpartition_point_acc<F>(&mut self, right: usize, mut pred: F) -> usize
    where
        F: FnMut(&T::Agg) -> bool,
    {
        let mut split3 = Split3::seek_by_size(&mut self.root, ..right);
        let split = split3.split_mid(SeekByRaccCond::new(|acc| !pred(acc)), EqualSide::Left);
        split
            .left()
            .map(|node| node.into_data().size)
            .unwrap_or_default()
    }

crates/competitive/src/data_structure/binary_search_tree/data.rs (line 44)

    pub fn bottom_up<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::MonoidAgg, Value = Self>>,
    {
        let mut agg = node.reborrow().into_data().bst_data().agg.clone();
        if let Ok(left) = node.reborrow().left().descend() {
            agg = M::operate(&left.into_data().bst_data().agg, &agg);
        }
        if let Ok(right) = node.reborrow().right().descend() {
            agg = M::operate(&agg, &right.into_data().bst_data().agg);
        }
        node.data_mut().bst_data_mut().agg = agg;
    }
}

pub struct MonoidActElement<M>
where
    M: MonoidAct,
{
    pub key: M::Key,
    pub act: M::Act,
}

impl<M> Debug for MonoidActElement<M>
where
    M: MonoidAct<Key: Debug, Act: Debug>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("MonoidActElement")
            .field("key", &self.key)
            .field("act", &self.act)
            .finish()
    }
}

impl<M> MonoidActElement<M>
where
    M: MonoidAct,
{
    pub fn from_key(key: M::Key) -> Self {
        Self {
            key,
            act: M::unit(),
        }
    }

    pub fn update_act<Spec>(mut node: BstDataMutRef<'_, Spec>, act: &M::Act)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::MonoidAct, Value = Self>>,
    {
        M::operate_assign(&mut node.data_mut().bst_data_mut().act, act);
        M::act_assign(&mut node.data_mut().bst_data_mut().key, act);
    }

    pub fn top_down<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::MonoidAct, Value = Self>>,
    {
        let act = replace(&mut node.data_mut().bst_data_mut().act, M::unit());
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::update_act(left, &act);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::update_act(right, &act);
        }
    }
}

pub struct LazyMapElement<L>
where
    L: LazyMapMonoid,
{
    pub key: L::Key,
    pub agg: L::Agg,
    pub act: L::Act,
}

impl<L> Debug for LazyMapElement<L>
where
    L: LazyMapMonoid<Key: Debug, Agg: Debug, Act: Debug>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("LazyMapElement")
            .field("key", &self.key)
            .field("agg", &self.agg)
            .field("act", &self.act)
            .finish()
    }
}

impl<L> LazyMapElement<L>
where
    L: LazyMapMonoid,
{
    pub fn from_key(key: L::Key) -> Self {
        let agg = L::single_agg(&key);
        Self {
            key,
            agg,
            act: L::act_unit(),
        }
    }

    pub fn update_act<Spec>(mut node: BstDataMutRef<'_, Spec>, act: &L::Act)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        if L::is_act_unit(act) {
            return;
        }
        L::act_operate_assign(&mut node.data_mut().bst_data_mut().act, act);
        node.data_mut().bst_data_mut().key =
            L::act_key(&node.reborrow().into_data().bst_data().key, act);
        if let Some(nxlazy) = L::act_agg(&node.reborrow().into_data().bst_data().agg, act) {
            node.data_mut().bst_data_mut().agg = nxlazy;
        } else {
            Self::top_down(node.reborrow_datamut());
            Self::bottom_up(node.reborrow_datamut());
        }
    }

    pub fn top_down<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        if L::is_act_unit(&node.reborrow().into_data().bst_data().act) {
            return;
        }
        let act = replace(&mut node.data_mut().bst_data_mut().act, L::act_unit());
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::update_act(left, &act);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::update_act(right, &act);
        }
    }

    pub fn bottom_up<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        let mut agg = L::single_agg(&node.reborrow().into_data().bst_data().key);
        if let Ok(left) = node.reborrow().left().descend() {
            agg = L::agg_operate(&left.into_data().bst_data().agg, &agg);
        }
        if let Ok(right) = node.reborrow().right().descend() {
            agg = L::agg_operate(&agg, &right.into_data().bst_data().agg);
        }
        node.data_mut().bst_data_mut().agg = agg;
    }

crates/competitive/src/tree/link_cut_tree.rs (line 101)

    fn top_down(mut node: BstDataMutRef<'_, Self>) {
        let pointer = node.node;
        if node.reborrow().into_data().index_and_reverse & 1 != 0 {
            node.data_mut().index_and_reverse &= !1;
            let children = unsafe { pointer.as_ref().child };
            for child in children.into_iter().flatten() {
                unsafe { Self::toggle(child) };
            }
        }
        let children = unsafe { pointer.as_ref().child };
        let data = unsafe { &mut (*pointer.as_ptr()).data.inner };
        let children =
            children.map(|child| child.map(|child| unsafe { &mut (*child.as_ptr()).data.inner }));
        S::top_down(data, children);
    }

Additional examples can be found in:

• crates/competitive/src/data_structure/treap.rs
• crates/competitive/src/tree/top_tree.rs

pub fn traverse<F>(self, f: &mut F)

where F: FnMut(Self),

Examples found in repository

crates/competitive/src/data_structure/binary_search_tree/node.rs (line 379)

    pub fn traverse<F>(self, f: &mut F)
    where
        F: FnMut(Self),
    {
        if let Ok(left) = self.left().descend() {
            left.traverse(f);
        }
        f(self);
        if let Ok(right) = self.right().descend() {
            right.traverse(f);
        }
    }

pub fn leftmost(self) -> Self

Examples found in repository

crates/competitive/src/data_structure/treap.rs (line 422)

    pub fn find_by_key<Q>(&mut self, key: &Q) -> Option<BstNodeId<TreapSpec<M, L>>>
    where
        M: MonoidAct<Key: Borrow<Q>>,
        Q: Ord + ?Sized,
    {
        let split = Split::new(
            &mut self.root,
            SeekByKey::<TreapSpec<M, L>, M::Key, Q>::new(key),
            EqualSide::Right,
        );
        let node = split.right()?.leftmost();
        matches!(node.into_data().key.key.borrow().cmp(key), Ordering::Equal)
            .then(|| self.node_id_manager.registered_node_id(node))
            .flatten()
    }

    pub fn find_by_acc_cond<F>(&mut self, f: F) -> Option<BstNodeId<TreapSpec<M, L>>>
    where
        F: FnMut(&L::Agg) -> bool,
    {
        let split = Split::new(
            &mut self.root,
            SeekByAccCond::<TreapSpec<M, L>, L, F>::new(f),
            EqualSide::Right,
        );
        let node = split.right()?.leftmost();
        self.node_id_manager.registered_node_id(node)
    }

pub fn rightmost(self) -> Self

Examples found in repository

crates/competitive/src/data_structure/treap.rs (line 450)

    pub fn find_by_racc_cond<F>(&mut self, f: F) -> Option<BstNodeId<TreapSpec<M, L>>>
    where
        F: FnMut(&L::Agg) -> bool,
    {
        let split = Split::new(
            &mut self.root,
            SeekByRaccCond::<TreapSpec<M, L>, L, F>::new(f),
            EqualSide::Left,
        );
        let node = split.left()?.rightmost();
        self.node_id_manager.registered_node_id(node)
    }

impl<'a, Spec> BstNodeRef<DataMut<'a>, Spec>

where Spec: BstSpec,

pub fn reborrow_datamut(&mut self) -> BstNodeRef<DataMut<'_>, Spec>

Examples found in repository

crates/competitive/src/data_structure/treap.rs (line 109)

    fn top_down(mut node: BstDataMutRef<'_, Self>) {
        MonoidActElement::<M>::top_down(node.reborrow_datamut());
        LazyMapElement::<L>::top_down(node.reborrow_datamut());
    }

    fn bottom_up(mut node: BstDataMutRef<'_, Self>) {
        LazyMapElement::<L>::bottom_up(node.reborrow_datamut());
    }

crates/competitive/src/data_structure/binary_search_tree/data.rs (line 99)

    pub fn top_down<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::MonoidAct, Value = Self>>,
    {
        let act = replace(&mut node.data_mut().bst_data_mut().act, M::unit());
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::update_act(left, &act);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::update_act(right, &act);
        }
    }
}

pub struct LazyMapElement<L>
where
    L: LazyMapMonoid,
{
    pub key: L::Key,
    pub agg: L::Agg,
    pub act: L::Act,
}

impl<L> Debug for LazyMapElement<L>
where
    L: LazyMapMonoid<Key: Debug, Agg: Debug, Act: Debug>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("LazyMapElement")
            .field("key", &self.key)
            .field("agg", &self.agg)
            .field("act", &self.act)
            .finish()
    }
}

impl<L> LazyMapElement<L>
where
    L: LazyMapMonoid,
{
    pub fn from_key(key: L::Key) -> Self {
        let agg = L::single_agg(&key);
        Self {
            key,
            agg,
            act: L::act_unit(),
        }
    }

    pub fn update_act<Spec>(mut node: BstDataMutRef<'_, Spec>, act: &L::Act)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        if L::is_act_unit(act) {
            return;
        }
        L::act_operate_assign(&mut node.data_mut().bst_data_mut().act, act);
        node.data_mut().bst_data_mut().key =
            L::act_key(&node.reborrow().into_data().bst_data().key, act);
        if let Some(nxlazy) = L::act_agg(&node.reborrow().into_data().bst_data().agg, act) {
            node.data_mut().bst_data_mut().agg = nxlazy;
        } else {
            Self::top_down(node.reborrow_datamut());
            Self::bottom_up(node.reborrow_datamut());
        }
    }

    pub fn top_down<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        if L::is_act_unit(&node.reborrow().into_data().bst_data().act) {
            return;
        }
        let act = replace(&mut node.data_mut().bst_data_mut().act, L::act_unit());
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::update_act(left, &act);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::update_act(right, &act);
        }
    }

crates/competitive/src/data_structure/implicit_splay_tree.rs (line 92)

    fn update_act(mut node: BstDataMutRef<'_, Self>, act: &T::Act) {
        if T::is_act_unit(act) {
            return;
        }
        T::act_operate_assign(&mut node.data_mut().value.act, act);
        node.data_mut().value.key = T::act_key(&node.reborrow().into_data().value.key, act);
        if let Some(agg) = T::act_agg(&node.reborrow().into_data().value.agg, act) {
            node.data_mut().value.agg = agg;
        } else {
            Self::top_down(node.reborrow_datamut());
            Self::bottom_up(node);
        }
    }

    fn reverse(mut node: BstDataMutRef<'_, Self>) {
        node.swap_children();
        let data = node.data_mut();
        T::toggle(&mut data.value.agg);
        data.rev ^= true;
    }
}

impl<T> BstSpec for ImplicitSplayTreeSpec<T>
where
    T: LazyMapMonoid,
{
    type Parent = WithNoParent<Self::Data>;
    type Data = ImplicitSplayTreeData<T>;

    fn top_down(mut node: BstDataMutRef<'_, Self>) {
        if !T::is_act_unit(&node.reborrow().into_data().value.act) {
            let act = replace(&mut node.data_mut().value.act, T::act_unit());
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::update_act(left, &act);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::update_act(right, &act);
            }
        }
        if node.reborrow().into_data().rev {
            node.data_mut().rev = false;
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::reverse(left);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::reverse(right);
            }
        }
    }

    fn bottom_up(mut node: BstDataMutRef<'_, Self>) {
        let mut agg = T::single_agg(&node.reborrow().into_data().value.key);
        let mut size = 1;
        if let Ok(left) = node.reborrow().left().descend() {
            let data = left.into_data();
            agg = T::agg_operate(&data.value.agg, &agg);
            size += data.size;
        }
        if let Ok(right) = node.reborrow().right().descend() {
            let data = right.into_data();
            agg = T::agg_operate(&agg, &data.value.agg);
            size += data.size;
        }
        let data = node.data_mut();
        data.value.agg = agg;
        data.size = size;
    }

    fn merge(
        left: Option<ImplicitSplayTreeRoot<T>>,
        right: Option<ImplicitSplayTreeRoot<T>>,
    ) -> Option<ImplicitSplayTreeRoot<T>> {
        splay_operations::merge(left, right)
    }

    fn split<Seeker>(
        node: Option<ImplicitSplayTreeRoot<T>>,
        seeker: Seeker,
        equal_side: EqualSide,
    ) -> (
        Option<ImplicitSplayTreeRoot<T>>,
        Option<ImplicitSplayTreeRoot<T>>,
    )
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        splay_operations::split(node, seeker, equal_side)
    }
}

pub struct ImplicitSplayTree<T, A = MemoryPool<ImplicitSplayTreeNode<T>>>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitSplayTreeNode<T>>,
{
    root: Option<ImplicitSplayTreeRoot<T>>,
    length: usize,
    allocator: ManuallyDrop<A>,
    _marker: PhantomData<fn() -> T>,
}

impl<T, A> Default for ImplicitSplayTree<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitSplayTreeNode<T>> + Default,
{
    fn default() -> Self {
        Self {
            root: None,
            length: 0,
            allocator: ManuallyDrop::new(A::default()),
            _marker: PhantomData,
        }
    }
}

impl<T, A> Drop for ImplicitSplayTree<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitSplayTreeNode<T>>,
{
    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }
}

impl<T> ImplicitSplayTree<T>
where
    T: LazyMapMonoid,
{
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            root: None,
            length: 0,
            allocator: ManuallyDrop::new(MemoryPool::with_capacity(capacity)),
            _marker: PhantomData,
        }
    }
}

impl<T, A> ImplicitSplayTree<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitSplayTreeNode<T>>,
{
    fn node(&mut self, key: T::Key) -> ImplicitSplayTreeRoot<T> {
        BstRoot::from_data(
            ImplicitSplayTreeData {
                value: LazyMapElement::from_key(key),
                size: 1,
                rev: false,
            },
            self.allocator.deref_mut(),
        )
    }

    #[inline]
    fn splay<Seeker>(&mut self, seeker: Seeker) -> Option<Ordering>
    where
        Seeker: BstSeeker<Spec = ImplicitSplayTreeSpec<T>>,
    {
        let (ordering, root) = splay_operations::splay(self.root.take()?, seeker);
        self.root = Some(root);
        Some(ordering)
    }

    pub fn len(&self) -> usize {
        self.length
    }

    pub fn is_empty(&self) -> bool {
        self.length == 0
    }

    pub fn update<R>(&mut self, range: R, act: T::Act)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitSplayTreeSpec::update_act(root, &act);
        }
    }

    pub fn fold<R>(&mut self, range: R) -> T::Agg
    where
        R: RangeBounds<usize>,
    {
        let split = Split3::seek_by_size(&mut self.root, range);
        split
            .mid()
            .map(|node| node.into_data().value.agg.clone())
            .unwrap_or_else(T::agg_unit)
    }

    pub fn reverse<R>(&mut self, range: R)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitSplayTreeSpec::reverse(root);
        }
    }

    pub fn get(&mut self, index: usize) -> Option<&T::Key> {
        if index >= self.length {
            return None;
        }
        self.splay(SeekBySize::new(index));
        Some(&self.root.as_ref()?.reborrow().into_data().value.key)
    }

    pub fn modify<F>(&mut self, index: usize, f: F)
    where
        F: FnOnce(&T::Key) -> T::Key,
    {
        assert!(index < self.length);
        self.splay(SeekBySize::new(index));
        let mut root = self.root.as_mut().unwrap().borrow_datamut();
        ImplicitSplayTreeSpec::top_down(root.reborrow_datamut());
        {
            let data = root.data_mut();
            data.value.key = f(&data.value.key);
        }
        ImplicitSplayTreeSpec::bottom_up(root);
    }

crates/competitive/src/data_structure/implicit_treap.rs (line 93)

    fn update_act(mut node: BstDataMutRef<'_, Self>, act: &T::Act) {
        if T::is_act_unit(act) {
            return;
        }
        T::act_operate_assign(&mut node.data_mut().value.act, act);
        node.data_mut().value.key = T::act_key(&node.reborrow().into_data().value.key, act);
        if let Some(agg) = T::act_agg(&node.reborrow().into_data().value.agg, act) {
            node.data_mut().value.agg = agg;
        } else {
            Self::top_down(node.reborrow_datamut());
            Self::bottom_up(node);
        }
    }

    fn reverse(mut node: BstDataMutRef<'_, Self>) {
        node.swap_children();
        let data = node.data_mut();
        T::toggle(&mut data.value.agg);
        data.rev ^= true;
    }
}

impl<T> BstSpec for ImplicitTreapSpec<T>
where
    T: LazyMapMonoid,
{
    type Parent = WithNoParent<Self::Data>;
    type Data = ImplicitTreapData<T>;

    fn top_down(mut node: BstDataMutRef<'_, Self>) {
        if !T::is_act_unit(&node.reborrow().into_data().value.act) {
            let act = replace(&mut node.data_mut().value.act, T::act_unit());
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::update_act(left, &act);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::update_act(right, &act);
            }
        }
        if node.reborrow().into_data().rev {
            node.data_mut().rev = false;
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::reverse(left);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::reverse(right);
            }
        }
    }

    fn bottom_up(mut node: BstDataMutRef<'_, Self>) {
        let mut agg = T::single_agg(&node.reborrow().into_data().value.key);
        let mut size = 1;
        if let Ok(left) = node.reborrow().left().descend() {
            let data = left.into_data();
            agg = T::agg_operate(&data.value.agg, &agg);
            size += data.size;
        }
        if let Ok(right) = node.reborrow().right().descend() {
            let data = right.into_data();
            agg = T::agg_operate(&agg, &data.value.agg);
            size += data.size;
        }
        let data = node.data_mut();
        data.value.agg = agg;
        data.size = size;
    }

    fn merge(
        left: Option<ImplicitTreapRoot<T>>,
        right: Option<ImplicitTreapRoot<T>>,
    ) -> Option<ImplicitTreapRoot<T>> {
        match (left, right) {
            (None, None) => None,
            (None, Some(node)) | (Some(node), None) => Some(node),
            (Some(mut left), Some(mut right)) => unsafe {
                if left.reborrow().into_data().priority > right.reborrow().into_data().priority {
                    Self::top_down(left.borrow_datamut());
                    let lr = left.borrow_mut().right().take();
                    let lr = Self::merge(lr, Some(right)).unwrap_unchecked();
                    left.borrow_mut().right().set(lr);
                    Self::bottom_up(left.borrow_datamut());
                    Some(left)
                } else {
                    Self::top_down(right.borrow_datamut());
                    let rl = right.borrow_mut().left().take();
                    let rl = Self::merge(Some(left), rl).unwrap_unchecked();
                    right.borrow_mut().left().set(rl);
                    Self::bottom_up(right.borrow_datamut());
                    Some(right)
                }
            },
        }
    }

    fn split<Seeker>(
        node: Option<ImplicitTreapRoot<T>>,
        mut seeker: Seeker,
        equal_side: EqualSide,
    ) -> (Option<ImplicitTreapRoot<T>>, Option<ImplicitTreapRoot<T>>)
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        match node {
            None => (None, None),
            Some(mut node) => {
                Self::top_down(node.borrow_datamut());
                if equal_side.goes_left(seeker.bst_seek(node.reborrow())) {
                    unsafe {
                        let right = node.borrow_mut().right().take();
                        let (l, r) = Self::split(right, seeker, equal_side);
                        if let Some(l) = l {
                            node.borrow_mut().right().set(l);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (Some(node), r)
                    }
                } else {
                    unsafe {
                        let left = node.borrow_mut().left().take();
                        let (l, r) = Self::split(left, seeker, equal_side);
                        if let Some(r) = r {
                            node.borrow_mut().left().set(r);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (l, Some(node))
                    }
                }
            }
        }
    }
}

pub struct ImplicitTreap<T, A = MemoryPool<ImplicitTreapNode<T>>>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>>,
{
    root: Option<ImplicitTreapRoot<T>>,
    length: usize,
    rng: Xorshift,
    allocator: ManuallyDrop<A>,
    _marker: PhantomData<fn() -> T>,
}

impl<T, A> Default for ImplicitTreap<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>> + Default,
{
    fn default() -> Self {
        Self {
            root: None,
            length: 0,
            rng: Xorshift::new(),
            allocator: ManuallyDrop::new(A::default()),
            _marker: PhantomData,
        }
    }
}

impl<T, A> Drop for ImplicitTreap<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>>,
{
    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }
}

impl<T> ImplicitTreap<T>
where
    T: LazyMapMonoid,
{
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            root: None,
            length: 0,
            rng: Xorshift::new(),
            allocator: ManuallyDrop::new(MemoryPool::with_capacity(capacity)),
            _marker: PhantomData,
        }
    }
}

impl<T, A> ImplicitTreap<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>>,
{
    fn node(&mut self, key: T::Key) -> ImplicitTreapRoot<T> {
        BstRoot::from_data(
            ImplicitTreapData {
                priority: self.rng.rand64(),
                value: LazyMapElement::from_key(key),
                size: 1,
                rev: false,
            },
            self.allocator.deref_mut(),
        )
    }

    fn build<I>(&mut self, iter: I) -> (Option<ImplicitTreapRoot<T>>, usize)
    where
        I: IntoIterator<Item = T::Key>,
    {
        let mut stack = vec![];
        let mut len = 0;
        for key in iter {
            let mut cur = self.node(key).node;
            let mut left = None;
            unsafe {
                while stack
                    .last()
                    .is_some_and(|node: &NonNull<ImplicitTreapNode<T>>| {
                        node.as_ref().data.priority < cur.as_ref().data.priority
                    })
                {
                    left = stack.pop();
                }
                cur.as_mut().child[0] = left;
                if let Some(parent) = stack.last_mut() {
                    parent.as_mut().child[1] = Some(cur);
                }
            }
            stack.push(cur);
            len += 1;
        }
        let root = stack.first().copied().map(BstRoot::new);
        if let Some(mut root) = root {
            Self::build_bottom_up(root.borrow_datamut());
            (Some(root), len)
        } else {
            (None, len)
        }
    }

    fn build_bottom_up(mut node: BstDataMutRef<'_, ImplicitTreapSpec<T>>) {
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::build_bottom_up(left);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::build_bottom_up(right);
        }
        ImplicitTreapSpec::<T>::bottom_up(node);
    }

    pub fn len(&self) -> usize {
        self.length
    }

    pub fn is_empty(&self) -> bool {
        self.length == 0
    }

    pub fn update<R>(&mut self, range: R, x: T::Act)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitTreapSpec::<T>::update_act(root, &x);
        }
    }

    pub fn fold<R>(&mut self, range: R) -> T::Agg
    where
        R: RangeBounds<usize>,
    {
        let split = Split3::seek_by_size(&mut self.root, range);
        split
            .mid()
            .map(|node| node.into_data().value.agg.clone())
            .unwrap_or_else(T::agg_unit)
    }

    pub fn reverse<R>(&mut self, range: R)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitTreapSpec::<T>::reverse(root);
        }
    }

    pub fn get(&mut self, index: usize) -> Option<&T::Key> {
        if index >= self.length {
            return None;
        }
        let split = Split3::seek_by_size(&mut self.root, index..=index);
        let node = split.mid()?.node;
        drop(split);
        Some(unsafe { &(*node.as_ptr()).data.value.key })
    }

    pub fn modify<F>(&mut self, index: usize, f: F)
    where
        F: FnOnce(&T::Key) -> T::Key,
    {
        assert!(index < self.length);
        let mut split = Split3::seek_by_size(&mut self.root, index..=index);
        let mut node = split.mid_datamut().unwrap();
        ImplicitTreapSpec::<T>::top_down(node.reborrow_datamut());
        {
            let data = node.data_mut();
            data.value.key = f(&data.value.key);
        }
        ImplicitTreapSpec::<T>::bottom_up(node);
    }

crates/competitive/src/data_structure/binary_search_tree/node.rs (line 146)

    pub fn resolve_top_down<Spec>(node: BstNodeRef<marker::DataMut<'_>, Spec>)
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        unsafe {
            let (mut node, mut stack) = node.root_path();
            while let Some(is_left) = stack.pop() {
                Spec::top_down(node.reborrow_datamut());
                if is_left {
                    node = node.left().descend().unwrap_unchecked();
                } else {
                    node = node.right().descend().unwrap_unchecked();
                }
            }
            Spec::top_down(node.reborrow_datamut());
        }
    }

    pub fn resolve_bottom_up<Spec>(mut node: BstNodeRef<marker::DataMut<'_>, Spec>)
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        loop {
            Spec::bottom_up(node.reborrow_datamut());
            match node.ascend() {
                Ok(parent) => node = parent,
                Err(_) => break,
            }
        }
    }

pub fn data_mut(&mut self) -> &mut Spec::Data

Examples found in repository

crates/competitive/src/data_structure/splay_tree.rs (line 91)

    fn bottom_up(mut node: BstDataMutRef<'_, Self>) {
        let left = node
            .reborrow()
            .left()
            .descend()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        let right = node
            .reborrow()
            .right()
            .descend()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        node.data_mut().size = left + right + 1;
    }

    #[inline]
    fn merge(
        left: Option<SplayTreeRoot<K, V>>,
        right: Option<SplayTreeRoot<K, V>>,
    ) -> Option<SplayTreeRoot<K, V>> {
        splay_operations::merge(left, right)
    }

    #[inline]
    fn split<Seeker>(
        node: Option<SplayTreeRoot<K, V>>,
        seeker: Seeker,
        equal_side: EqualSide,
    ) -> (Option<SplayTreeRoot<K, V>>, Option<SplayTreeRoot<K, V>>)
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        splay_operations::split(node, seeker, equal_side)
    }
}

pub struct SplayTree<K, V, A = MemoryPool<SplayTreeNode<K, V>>>
where
    A: Allocator<SplayTreeNode<K, V>>,
{
    root: Option<SplayTreeRoot<K, V>>,
    length: usize,
    allocator: ManuallyDrop<A>,
}

impl<K, V, A> Debug for SplayTree<K, V, A>
where
    K: Debug,
    V: Debug,
    A: Allocator<SplayTreeNode<K, V>>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("SplayTree")
            .field("length", &self.length)
            .finish_non_exhaustive()
    }
}

impl<K, V, A> Default for SplayTree<K, V, A>
where
    A: Allocator<SplayTreeNode<K, V>> + Default,
{
    fn default() -> Self {
        Self {
            root: None,
            length: 0,
            allocator: ManuallyDrop::new(A::default()),
        }
    }
}

impl<K, V, A> Drop for SplayTree<K, V, A>
where
    A: Allocator<SplayTreeNode<K, V>>,
{
    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }
}

impl<K, V> SplayTree<K, V> {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            root: None,
            length: 0,
            allocator: ManuallyDrop::new(MemoryPool::with_capacity(capacity)),
        }
    }
}

impl<K, V, A> SplayTree<K, V, A>
where
    A: Allocator<SplayTreeNode<K, V>>,
{
    #[inline]
    fn splay<Seeker>(&mut self, seeker: Seeker) -> Option<Ordering>
    where
        Seeker: BstSeeker<Spec = SplayTreeSpec<K, V>>,
    {
        let (ordering, root) = splay_operations::splay(self.root.take()?, seeker);
        self.root = Some(root);
        Some(ordering)
    }

    fn splay_by_key<Q>(&mut self, key: &Q) -> Option<Ordering>
    where
        K: Borrow<Q>,
        Q: Ord + ?Sized,
    {
        self.splay(SeekByKey::new(key))
    }

    fn splay_by_size(&mut self, index: usize) -> Option<Ordering> {
        self.splay(SeekBySize::new(index))
    }

    pub fn get<Q>(&mut self, key: &Q) -> Option<&V>
    where
        K: Borrow<Q>,
        Q: Ord + ?Sized,
    {
        self.get_key_value(key).map(|(_, value)| value)
    }

    pub fn get_key_value<Q>(&mut self, key: &Q) -> Option<(&K, &V)>
    where
        K: Borrow<Q>,
        Q: Ord + ?Sized,
    {
        matches!(self.splay_by_key(key)?, Ordering::Equal).then(|| {
            let data = self.root.as_ref().unwrap().reborrow().into_data();
            (&data.key, &data.value)
        })
    }

    pub fn get_key_value_at(&mut self, index: usize) -> Option<(&K, &V)> {
        if index >= self.length {
            return None;
        }
        self.splay_by_size(index);
        let data = self.root.as_ref()?.reborrow().into_data();
        Some((&data.key, &data.value))
    }

    pub fn insert(&mut self, key: K, value: V) -> Option<V>
    where
        K: Ord,
    {
        let ordering = self.splay_by_key(&key);
        if matches!(ordering, Some(Ordering::Equal)) {
            return Some(replace(
                &mut self
                    .root
                    .as_mut()
                    .unwrap()
                    .borrow_datamut()
                    .data_mut()
                    .value,
                value,
            ));
        }
        let mut node = BstRoot::from_data(
            SplayTreeData {
                key,
                value,
                size: 1,
            },
            self.allocator.deref_mut(),
        );
        if let Some(mut root) = self.root.take() {
            match ordering.unwrap() {
                Ordering::Greater => {
                    let left = unsafe { root.borrow_mut().left_mut().take() };
                    if let Some(left) = left {
                        unsafe { node.borrow_mut().left_mut().set(left) };
                    }
                    SplayTreeSpec::bottom_up(root.borrow_datamut());
                    unsafe { node.borrow_mut().right_mut().set(root) };
                }
                Ordering::Less => {
                    let right = unsafe { root.borrow_mut().right_mut().take() };
                    if let Some(right) = right {
                        unsafe { node.borrow_mut().right_mut().set(right) };
                    }
                    SplayTreeSpec::bottom_up(root.borrow_datamut());
                    unsafe { node.borrow_mut().left_mut().set(root) };
                }
                Ordering::Equal => unreachable!(),
            }
            SplayTreeSpec::bottom_up(node.borrow_datamut());
        }
        self.root = Some(node);
        self.length += 1;
        None
    }

crates/competitive/src/data_structure/implicit_splay_tree.rs (line 87)

    fn update_act(mut node: BstDataMutRef<'_, Self>, act: &T::Act) {
        if T::is_act_unit(act) {
            return;
        }
        T::act_operate_assign(&mut node.data_mut().value.act, act);
        node.data_mut().value.key = T::act_key(&node.reborrow().into_data().value.key, act);
        if let Some(agg) = T::act_agg(&node.reborrow().into_data().value.agg, act) {
            node.data_mut().value.agg = agg;
        } else {
            Self::top_down(node.reborrow_datamut());
            Self::bottom_up(node);
        }
    }

    fn reverse(mut node: BstDataMutRef<'_, Self>) {
        node.swap_children();
        let data = node.data_mut();
        T::toggle(&mut data.value.agg);
        data.rev ^= true;
    }
}

impl<T> BstSpec for ImplicitSplayTreeSpec<T>
where
    T: LazyMapMonoid,
{
    type Parent = WithNoParent<Self::Data>;
    type Data = ImplicitSplayTreeData<T>;

    fn top_down(mut node: BstDataMutRef<'_, Self>) {
        if !T::is_act_unit(&node.reborrow().into_data().value.act) {
            let act = replace(&mut node.data_mut().value.act, T::act_unit());
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::update_act(left, &act);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::update_act(right, &act);
            }
        }
        if node.reborrow().into_data().rev {
            node.data_mut().rev = false;
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::reverse(left);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::reverse(right);
            }
        }
    }

    fn bottom_up(mut node: BstDataMutRef<'_, Self>) {
        let mut agg = T::single_agg(&node.reborrow().into_data().value.key);
        let mut size = 1;
        if let Ok(left) = node.reborrow().left().descend() {
            let data = left.into_data();
            agg = T::agg_operate(&data.value.agg, &agg);
            size += data.size;
        }
        if let Ok(right) = node.reborrow().right().descend() {
            let data = right.into_data();
            agg = T::agg_operate(&agg, &data.value.agg);
            size += data.size;
        }
        let data = node.data_mut();
        data.value.agg = agg;
        data.size = size;
    }

    fn merge(
        left: Option<ImplicitSplayTreeRoot<T>>,
        right: Option<ImplicitSplayTreeRoot<T>>,
    ) -> Option<ImplicitSplayTreeRoot<T>> {
        splay_operations::merge(left, right)
    }

    fn split<Seeker>(
        node: Option<ImplicitSplayTreeRoot<T>>,
        seeker: Seeker,
        equal_side: EqualSide,
    ) -> (
        Option<ImplicitSplayTreeRoot<T>>,
        Option<ImplicitSplayTreeRoot<T>>,
    )
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        splay_operations::split(node, seeker, equal_side)
    }
}

pub struct ImplicitSplayTree<T, A = MemoryPool<ImplicitSplayTreeNode<T>>>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitSplayTreeNode<T>>,
{
    root: Option<ImplicitSplayTreeRoot<T>>,
    length: usize,
    allocator: ManuallyDrop<A>,
    _marker: PhantomData<fn() -> T>,
}

impl<T, A> Default for ImplicitSplayTree<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitSplayTreeNode<T>> + Default,
{
    fn default() -> Self {
        Self {
            root: None,
            length: 0,
            allocator: ManuallyDrop::new(A::default()),
            _marker: PhantomData,
        }
    }
}

impl<T, A> Drop for ImplicitSplayTree<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitSplayTreeNode<T>>,
{
    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }
}

impl<T> ImplicitSplayTree<T>
where
    T: LazyMapMonoid,
{
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            root: None,
            length: 0,
            allocator: ManuallyDrop::new(MemoryPool::with_capacity(capacity)),
            _marker: PhantomData,
        }
    }
}

impl<T, A> ImplicitSplayTree<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitSplayTreeNode<T>>,
{
    fn node(&mut self, key: T::Key) -> ImplicitSplayTreeRoot<T> {
        BstRoot::from_data(
            ImplicitSplayTreeData {
                value: LazyMapElement::from_key(key),
                size: 1,
                rev: false,
            },
            self.allocator.deref_mut(),
        )
    }

    #[inline]
    fn splay<Seeker>(&mut self, seeker: Seeker) -> Option<Ordering>
    where
        Seeker: BstSeeker<Spec = ImplicitSplayTreeSpec<T>>,
    {
        let (ordering, root) = splay_operations::splay(self.root.take()?, seeker);
        self.root = Some(root);
        Some(ordering)
    }

    pub fn len(&self) -> usize {
        self.length
    }

    pub fn is_empty(&self) -> bool {
        self.length == 0
    }

    pub fn update<R>(&mut self, range: R, act: T::Act)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitSplayTreeSpec::update_act(root, &act);
        }
    }

    pub fn fold<R>(&mut self, range: R) -> T::Agg
    where
        R: RangeBounds<usize>,
    {
        let split = Split3::seek_by_size(&mut self.root, range);
        split
            .mid()
            .map(|node| node.into_data().value.agg.clone())
            .unwrap_or_else(T::agg_unit)
    }

    pub fn reverse<R>(&mut self, range: R)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitSplayTreeSpec::reverse(root);
        }
    }

    pub fn get(&mut self, index: usize) -> Option<&T::Key> {
        if index >= self.length {
            return None;
        }
        self.splay(SeekBySize::new(index));
        Some(&self.root.as_ref()?.reborrow().into_data().value.key)
    }

    pub fn modify<F>(&mut self, index: usize, f: F)
    where
        F: FnOnce(&T::Key) -> T::Key,
    {
        assert!(index < self.length);
        self.splay(SeekBySize::new(index));
        let mut root = self.root.as_mut().unwrap().borrow_datamut();
        ImplicitSplayTreeSpec::top_down(root.reborrow_datamut());
        {
            let data = root.data_mut();
            data.value.key = f(&data.value.key);
        }
        ImplicitSplayTreeSpec::bottom_up(root);
    }

crates/competitive/src/data_structure/implicit_treap.rs (line 88)

    fn update_act(mut node: BstDataMutRef<'_, Self>, act: &T::Act) {
        if T::is_act_unit(act) {
            return;
        }
        T::act_operate_assign(&mut node.data_mut().value.act, act);
        node.data_mut().value.key = T::act_key(&node.reborrow().into_data().value.key, act);
        if let Some(agg) = T::act_agg(&node.reborrow().into_data().value.agg, act) {
            node.data_mut().value.agg = agg;
        } else {
            Self::top_down(node.reborrow_datamut());
            Self::bottom_up(node);
        }
    }

    fn reverse(mut node: BstDataMutRef<'_, Self>) {
        node.swap_children();
        let data = node.data_mut();
        T::toggle(&mut data.value.agg);
        data.rev ^= true;
    }
}

impl<T> BstSpec for ImplicitTreapSpec<T>
where
    T: LazyMapMonoid,
{
    type Parent = WithNoParent<Self::Data>;
    type Data = ImplicitTreapData<T>;

    fn top_down(mut node: BstDataMutRef<'_, Self>) {
        if !T::is_act_unit(&node.reborrow().into_data().value.act) {
            let act = replace(&mut node.data_mut().value.act, T::act_unit());
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::update_act(left, &act);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::update_act(right, &act);
            }
        }
        if node.reborrow().into_data().rev {
            node.data_mut().rev = false;
            if let Ok(left) = node.reborrow_datamut().left().descend() {
                Self::reverse(left);
            }
            if let Ok(right) = node.reborrow_datamut().right().descend() {
                Self::reverse(right);
            }
        }
    }

    fn bottom_up(mut node: BstDataMutRef<'_, Self>) {
        let mut agg = T::single_agg(&node.reborrow().into_data().value.key);
        let mut size = 1;
        if let Ok(left) = node.reborrow().left().descend() {
            let data = left.into_data();
            agg = T::agg_operate(&data.value.agg, &agg);
            size += data.size;
        }
        if let Ok(right) = node.reborrow().right().descend() {
            let data = right.into_data();
            agg = T::agg_operate(&agg, &data.value.agg);
            size += data.size;
        }
        let data = node.data_mut();
        data.value.agg = agg;
        data.size = size;
    }

    fn merge(
        left: Option<ImplicitTreapRoot<T>>,
        right: Option<ImplicitTreapRoot<T>>,
    ) -> Option<ImplicitTreapRoot<T>> {
        match (left, right) {
            (None, None) => None,
            (None, Some(node)) | (Some(node), None) => Some(node),
            (Some(mut left), Some(mut right)) => unsafe {
                if left.reborrow().into_data().priority > right.reborrow().into_data().priority {
                    Self::top_down(left.borrow_datamut());
                    let lr = left.borrow_mut().right().take();
                    let lr = Self::merge(lr, Some(right)).unwrap_unchecked();
                    left.borrow_mut().right().set(lr);
                    Self::bottom_up(left.borrow_datamut());
                    Some(left)
                } else {
                    Self::top_down(right.borrow_datamut());
                    let rl = right.borrow_mut().left().take();
                    let rl = Self::merge(Some(left), rl).unwrap_unchecked();
                    right.borrow_mut().left().set(rl);
                    Self::bottom_up(right.borrow_datamut());
                    Some(right)
                }
            },
        }
    }

    fn split<Seeker>(
        node: Option<ImplicitTreapRoot<T>>,
        mut seeker: Seeker,
        equal_side: EqualSide,
    ) -> (Option<ImplicitTreapRoot<T>>, Option<ImplicitTreapRoot<T>>)
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        match node {
            None => (None, None),
            Some(mut node) => {
                Self::top_down(node.borrow_datamut());
                if equal_side.goes_left(seeker.bst_seek(node.reborrow())) {
                    unsafe {
                        let right = node.borrow_mut().right().take();
                        let (l, r) = Self::split(right, seeker, equal_side);
                        if let Some(l) = l {
                            node.borrow_mut().right().set(l);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (Some(node), r)
                    }
                } else {
                    unsafe {
                        let left = node.borrow_mut().left().take();
                        let (l, r) = Self::split(left, seeker, equal_side);
                        if let Some(r) = r {
                            node.borrow_mut().left().set(r);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (l, Some(node))
                    }
                }
            }
        }
    }
}

pub struct ImplicitTreap<T, A = MemoryPool<ImplicitTreapNode<T>>>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>>,
{
    root: Option<ImplicitTreapRoot<T>>,
    length: usize,
    rng: Xorshift,
    allocator: ManuallyDrop<A>,
    _marker: PhantomData<fn() -> T>,
}

impl<T, A> Default for ImplicitTreap<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>> + Default,
{
    fn default() -> Self {
        Self {
            root: None,
            length: 0,
            rng: Xorshift::new(),
            allocator: ManuallyDrop::new(A::default()),
            _marker: PhantomData,
        }
    }
}

impl<T, A> Drop for ImplicitTreap<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>>,
{
    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }
}

impl<T> ImplicitTreap<T>
where
    T: LazyMapMonoid,
{
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            root: None,
            length: 0,
            rng: Xorshift::new(),
            allocator: ManuallyDrop::new(MemoryPool::with_capacity(capacity)),
            _marker: PhantomData,
        }
    }
}

impl<T, A> ImplicitTreap<T, A>
where
    T: LazyMapMonoid,
    A: Allocator<ImplicitTreapNode<T>>,
{
    fn node(&mut self, key: T::Key) -> ImplicitTreapRoot<T> {
        BstRoot::from_data(
            ImplicitTreapData {
                priority: self.rng.rand64(),
                value: LazyMapElement::from_key(key),
                size: 1,
                rev: false,
            },
            self.allocator.deref_mut(),
        )
    }

    fn build<I>(&mut self, iter: I) -> (Option<ImplicitTreapRoot<T>>, usize)
    where
        I: IntoIterator<Item = T::Key>,
    {
        let mut stack = vec![];
        let mut len = 0;
        for key in iter {
            let mut cur = self.node(key).node;
            let mut left = None;
            unsafe {
                while stack
                    .last()
                    .is_some_and(|node: &NonNull<ImplicitTreapNode<T>>| {
                        node.as_ref().data.priority < cur.as_ref().data.priority
                    })
                {
                    left = stack.pop();
                }
                cur.as_mut().child[0] = left;
                if let Some(parent) = stack.last_mut() {
                    parent.as_mut().child[1] = Some(cur);
                }
            }
            stack.push(cur);
            len += 1;
        }
        let root = stack.first().copied().map(BstRoot::new);
        if let Some(mut root) = root {
            Self::build_bottom_up(root.borrow_datamut());
            (Some(root), len)
        } else {
            (None, len)
        }
    }

    fn build_bottom_up(mut node: BstDataMutRef<'_, ImplicitTreapSpec<T>>) {
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::build_bottom_up(left);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::build_bottom_up(right);
        }
        ImplicitTreapSpec::<T>::bottom_up(node);
    }

    pub fn len(&self) -> usize {
        self.length
    }

    pub fn is_empty(&self) -> bool {
        self.length == 0
    }

    pub fn update<R>(&mut self, range: R, x: T::Act)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitTreapSpec::<T>::update_act(root, &x);
        }
    }

    pub fn fold<R>(&mut self, range: R) -> T::Agg
    where
        R: RangeBounds<usize>,
    {
        let split = Split3::seek_by_size(&mut self.root, range);
        split
            .mid()
            .map(|node| node.into_data().value.agg.clone())
            .unwrap_or_else(T::agg_unit)
    }

    pub fn reverse<R>(&mut self, range: R)
    where
        R: RangeBounds<usize>,
    {
        let mut split = Split3::seek_by_size(&mut self.root, range);
        if let Some(root) = split.mid_datamut() {
            ImplicitTreapSpec::<T>::reverse(root);
        }
    }

    pub fn get(&mut self, index: usize) -> Option<&T::Key> {
        if index >= self.length {
            return None;
        }
        let split = Split3::seek_by_size(&mut self.root, index..=index);
        let node = split.mid()?.node;
        drop(split);
        Some(unsafe { &(*node.as_ptr()).data.value.key })
    }

    pub fn modify<F>(&mut self, index: usize, f: F)
    where
        F: FnOnce(&T::Key) -> T::Key,
    {
        assert!(index < self.length);
        let mut split = Split3::seek_by_size(&mut self.root, index..=index);
        let mut node = split.mid_datamut().unwrap();
        ImplicitTreapSpec::<T>::top_down(node.reborrow_datamut());
        {
            let data = node.data_mut();
            data.value.key = f(&data.value.key);
        }
        ImplicitTreapSpec::<T>::bottom_up(node);
    }

crates/competitive/src/data_structure/binary_search_tree/data.rs (line 51)

    pub fn bottom_up<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::MonoidAgg, Value = Self>>,
    {
        let mut agg = node.reborrow().into_data().bst_data().agg.clone();
        if let Ok(left) = node.reborrow().left().descend() {
            agg = M::operate(&left.into_data().bst_data().agg, &agg);
        }
        if let Ok(right) = node.reborrow().right().descend() {
            agg = M::operate(&agg, &right.into_data().bst_data().agg);
        }
        node.data_mut().bst_data_mut().agg = agg;
    }
}

pub struct MonoidActElement<M>
where
    M: MonoidAct,
{
    pub key: M::Key,
    pub act: M::Act,
}

impl<M> Debug for MonoidActElement<M>
where
    M: MonoidAct<Key: Debug, Act: Debug>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("MonoidActElement")
            .field("key", &self.key)
            .field("act", &self.act)
            .finish()
    }
}

impl<M> MonoidActElement<M>
where
    M: MonoidAct,
{
    pub fn from_key(key: M::Key) -> Self {
        Self {
            key,
            act: M::unit(),
        }
    }

    pub fn update_act<Spec>(mut node: BstDataMutRef<'_, Spec>, act: &M::Act)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::MonoidAct, Value = Self>>,
    {
        M::operate_assign(&mut node.data_mut().bst_data_mut().act, act);
        M::act_assign(&mut node.data_mut().bst_data_mut().key, act);
    }

    pub fn top_down<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::MonoidAct, Value = Self>>,
    {
        let act = replace(&mut node.data_mut().bst_data_mut().act, M::unit());
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::update_act(left, &act);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::update_act(right, &act);
        }
    }
}

pub struct LazyMapElement<L>
where
    L: LazyMapMonoid,
{
    pub key: L::Key,
    pub agg: L::Agg,
    pub act: L::Act,
}

impl<L> Debug for LazyMapElement<L>
where
    L: LazyMapMonoid<Key: Debug, Agg: Debug, Act: Debug>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("LazyMapElement")
            .field("key", &self.key)
            .field("agg", &self.agg)
            .field("act", &self.act)
            .finish()
    }
}

impl<L> LazyMapElement<L>
where
    L: LazyMapMonoid,
{
    pub fn from_key(key: L::Key) -> Self {
        let agg = L::single_agg(&key);
        Self {
            key,
            agg,
            act: L::act_unit(),
        }
    }

    pub fn update_act<Spec>(mut node: BstDataMutRef<'_, Spec>, act: &L::Act)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        if L::is_act_unit(act) {
            return;
        }
        L::act_operate_assign(&mut node.data_mut().bst_data_mut().act, act);
        node.data_mut().bst_data_mut().key =
            L::act_key(&node.reborrow().into_data().bst_data().key, act);
        if let Some(nxlazy) = L::act_agg(&node.reborrow().into_data().bst_data().agg, act) {
            node.data_mut().bst_data_mut().agg = nxlazy;
        } else {
            Self::top_down(node.reborrow_datamut());
            Self::bottom_up(node.reborrow_datamut());
        }
    }

    pub fn top_down<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        if L::is_act_unit(&node.reborrow().into_data().bst_data().act) {
            return;
        }
        let act = replace(&mut node.data_mut().bst_data_mut().act, L::act_unit());
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::update_act(left, &act);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::update_act(right, &act);
        }
    }

    pub fn bottom_up<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        let mut agg = L::single_agg(&node.reborrow().into_data().bst_data().key);
        if let Ok(left) = node.reborrow().left().descend() {
            agg = L::agg_operate(&left.into_data().bst_data().agg, &agg);
        }
        if let Ok(right) = node.reborrow().right().descend() {
            agg = L::agg_operate(&agg, &right.into_data().bst_data().agg);
        }
        node.data_mut().bst_data_mut().agg = agg;
    }

crates/competitive/src/tree/link_cut_tree.rs (line 102)

    fn top_down(mut node: BstDataMutRef<'_, Self>) {
        let pointer = node.node;
        if node.reborrow().into_data().index_and_reverse & 1 != 0 {
            node.data_mut().index_and_reverse &= !1;
            let children = unsafe { pointer.as_ref().child };
            for child in children.into_iter().flatten() {
                unsafe { Self::toggle(child) };
            }
        }
        let children = unsafe { pointer.as_ref().child };
        let data = unsafe { &mut (*pointer.as_ptr()).data.inner };
        let children =
            children.map(|child| child.map(|child| unsafe { &mut (*child.as_ptr()).data.inner }));
        S::top_down(data, children);
    }

crates/competitive/src/tree/top_tree.rs (line 160)

    fn top_down(mut node: BstDataMutRef<'_, Self>) {
        let pointer = node.node;
        if node.reborrow().into_data().index_and_reverse & 1 != 0 {
            node.data_mut().index_and_reverse &= !1;
            for child in unsafe { pointer.as_ref().child }.into_iter().flatten() {
                unsafe { Self::toggle(child) };
            }
        }

        if !Self::is_unit(&node.reborrow().into_data().heavy_action) {
            let action = replace(
                &mut node.data_mut().heavy_action,
                <A::ActionMonoid as Unital>::unit(),
            );
            for child in unsafe { pointer.as_ref().child }.into_iter().flatten() {
                unsafe { Self::apply_heavy(child, &action) };
            }
        }
        if !Self::is_unit(&node.reborrow().into_data().light_action) {
            let action = replace(
                &mut node.data_mut().light_action,
                <A::ActionMonoid as Unital>::unit(),
            );
            for child in unsafe { pointer.as_ref().child }.into_iter().flatten() {
                unsafe { Self::apply_light(child, &action) };
            }
            if let Some(light) = node.reborrow().into_data().light {
                unsafe { RakeBstSpec::<S, A>::apply(light, &action) };
            }
        }
    }

    #[inline]
    fn bottom_up(node: BstDataMutRef<'_, Self>) {
        let pointer = node.node;
        let data = unsafe { &mut (*pointer.as_ptr()).data };
        let mut sum = if let Some(light) = data.light {
            S::add_vertex(unsafe { &light.as_ref().data.sum }, &data.info)
        } else {
            S::vertex(&data.info)
        };
        if let Some(left) = unsafe { pointer.as_ref().child[0] } {
            sum = S::compress(unsafe { &left.as_ref().data.sum }, &sum);
        }
        if let Some(right) = unsafe { pointer.as_ref().child[1] } {
            sum = S::compress(&sum, unsafe { &right.as_ref().data.sum });
        }
        data.sum = sum;
    }

    fn merge(_left: Option<BstRoot<Self>>, _right: Option<BstRoot<Self>>) -> Option<BstRoot<Self>> {
        unreachable!("top trees do not merge auxiliary trees through BstSpec")
    }

    fn split<Seeker>(
        _node: Option<BstRoot<Self>>,
        _seeker: Seeker,
        _equal_side: EqualSide,
    ) -> (Option<BstRoot<Self>>, Option<BstRoot<Self>>)
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        unreachable!("top trees do not split auxiliary trees through BstSpec")
    }
}

impl<S, A> RakeBstSpec<S, A>
where
    S: TopTreeSpec,
    A: TopTreeAction<S>,
{
    #[inline]
    unsafe fn apply(mut node: RakePtr<S, A>, action: &A::Action) {
        let data = unsafe { &mut node.as_mut().data };
        A::act_point(&mut data.key, action);
        A::act_point(&mut data.sum, action);
        TopBstSpec::<S, A>::compose(&mut data.action, action);
        TopBstSpec::<S, A>::compose(&mut data.buffer, action);
    }
}

impl<S, A> BstSpec for RakeBstSpec<S, A>
where
    S: TopTreeSpec,
    A: TopTreeAction<S>,
{
    type Parent = WithParent<Self::Data>;
    type Data = RakeData<S, A>;

    #[inline]
    fn top_down(mut node: BstDataMutRef<'_, Self>) {
        if TopBstSpec::<S, A>::is_unit(&node.reborrow().into_data().action) {
            return;
        }
        let pointer = node.node;
        let action = replace(
            &mut node.data_mut().action,
            <A::ActionMonoid as Unital>::unit(),
        );
        for child in unsafe { pointer.as_ref().child }.into_iter().flatten() {
            unsafe { Self::apply(child, &action) };
        }
    }

pub fn swap_children(&mut self)

Examples found in repository

crates/competitive/src/data_structure/implicit_splay_tree.rs (line 98)

    fn reverse(mut node: BstDataMutRef<'_, Self>) {
        node.swap_children();
        let data = node.data_mut();
        T::toggle(&mut data.value.agg);
        data.rev ^= true;
    }

crates/competitive/src/data_structure/implicit_treap.rs (line 99)

    fn reverse(mut node: BstDataMutRef<'_, Self>) {
        node.swap_children();
        let data = node.data_mut();
        T::toggle(&mut data.value.agg);
        data.rev ^= true;
    }

impl<'a, Spec> BstNodeRef<DataMut<'a>, Spec>

where Spec: BstSpec<Parent: 'a, Data: 'a>,

pub fn into_data_mut(self) -> &'a mut Spec::Data

Examples found in repository

crates/competitive/src/data_structure/treap.rs (line 333)

    pub fn change(
        &mut self,
        node_id: BstNodeId<TreapSpec<M, L>>,
        f: impl FnOnce(&mut L::Key),
    ) -> bool {
        if !self.node_id_manager.contains(&node_id) {
            return false;
        }
        unsafe {
            WithParent::resolve_top_down::<TreapSpec<M, L>>(
                node_id.reborrow_datamut(&mut self.root),
            );
            let data = node_id.reborrow_datamut(&mut self.root).into_data_mut();
            f(&mut data.value.key);
            WithParent::resolve_bottom_up::<TreapSpec<M, L>>(
                node_id.reborrow_datamut(&mut self.root),
            );
        }
        true
    }

    pub fn change_key_value(
        &mut self,
        node_id: BstNodeId<TreapSpec<M, L>>,
        f: impl FnOnce(&mut M::Key, &mut L::Key),
    ) -> bool {
        if !self.node_id_manager.contains(&node_id) {
            return false;
        }
        unsafe {
            WithParent::resolve_top_down::<TreapSpec<M, L>>(
                node_id.reborrow_datamut(&mut self.root),
            );
            let mut node = if WithParent::is_root(node_id.reborrow(&self.root)) {
                WithParent::remove_root(&mut self.root).unwrap_unchecked()
            } else {
                WithParent::remove_not_root(node_id.reborrow_mut(&mut self.root))
            };
            let data = node.borrow_datamut().into_data_mut();
            f(&mut data.key.key, &mut data.value.key);
            self.root = TreapSpec::merge_ordered(self.root.take(), Some(node));
            true
        }
    }

impl<'a, Spec> BstNodeRef<Mut<'a>, Spec>

where Spec: BstSpec,

pub fn reborrow_datamut(&mut self) -> BstNodeRef<DataMut<'_>, Spec>

Examples found in repository

crates/competitive/src/data_structure/binary_search_tree/node.rs (line 217)

    pub unsafe fn remove_not_root<Spec>(
        mut node: BstNodeRef<marker::Mut<'_>, Spec>,
    ) -> BstNodeRef<marker::Owned, Spec>
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        assert!(!Self::is_root(node.reborrow()));
        unsafe {
            let left = node.left_mut().take();
            let right = node.right_mut().take();
            let merged = Spec::merge(left, right);
            let node_inner = node.node;
            let mut parent = node.ascend().unwrap_unchecked();
            let mut node = if let Some(merged) = merged {
                let node = if parent
                    .reborrow()
                    .left()
                    .descend()
                    .is_ok_and(|n| n.node == node_inner)
                {
                    parent.left_mut().replace(merged)
                } else {
                    parent.right_mut().replace(merged)
                };
                Self::resolve_bottom_up(parent.reborrow_datamut());
                node.unwrap_unchecked()
            } else {
                let node = if parent
                    .reborrow()
                    .left()
                    .descend()
                    .is_ok_and(|n| n.node == node_inner)
                {
                    parent.left_mut().take()
                } else {
                    parent.right_mut().take()
                };
                Self::resolve_bottom_up(parent.reborrow_datamut());
                node.unwrap_unchecked()
            };
            Spec::bottom_up(node.borrow_datamut());
            node
        }
    }

pub fn left_mut(&mut self) -> BstEdgeHandle<BstNodeRef<Mut<'_>, Spec>, Left>

Examples found in repository

crates/competitive/src/data_structure/binary_search_tree/node.rs (line 185)

    pub unsafe fn remove_root<Spec>(
        root: &mut Option<BstRoot<Spec>>,
    ) -> Option<BstNodeRef<marker::Owned, Spec>>
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        let mut node = root.take()?;
        unsafe {
            let left = node.borrow_mut().left_mut().take();
            let right = node.borrow_mut().right_mut().take();
            *root = Spec::merge(left, right);
            Spec::bottom_up(node.borrow_datamut());
            Some(node)
        }
    }

    pub unsafe fn remove_not_root<Spec>(
        mut node: BstNodeRef<marker::Mut<'_>, Spec>,
    ) -> BstNodeRef<marker::Owned, Spec>
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        assert!(!Self::is_root(node.reborrow()));
        unsafe {
            let left = node.left_mut().take();
            let right = node.right_mut().take();
            let merged = Spec::merge(left, right);
            let node_inner = node.node;
            let mut parent = node.ascend().unwrap_unchecked();
            let mut node = if let Some(merged) = merged {
                let node = if parent
                    .reborrow()
                    .left()
                    .descend()
                    .is_ok_and(|n| n.node == node_inner)
                {
                    parent.left_mut().replace(merged)
                } else {
                    parent.right_mut().replace(merged)
                };
                Self::resolve_bottom_up(parent.reborrow_datamut());
                node.unwrap_unchecked()
            } else {
                let node = if parent
                    .reborrow()
                    .left()
                    .descend()
                    .is_ok_and(|n| n.node == node_inner)
                {
                    parent.left_mut().take()
                } else {
                    parent.right_mut().take()
                };
                Self::resolve_bottom_up(parent.reborrow_datamut());
                node.unwrap_unchecked()
            };
            Spec::bottom_up(node.borrow_datamut());
            node
        }
    }

crates/competitive/src/data_structure/implicit_splay_tree.rs (line 327)

    pub fn insert(&mut self, index: usize, key: T::Key) {
        assert!(index <= self.length);
        let mut node = self.node(key);
        if self.root.is_none() {
            self.root = Some(node);
        } else if index == self.length {
            self.splay(SeekBySize::new(index));
            unsafe { node.borrow_mut().left_mut().set(self.root.take().unwrap()) };
            ImplicitSplayTreeSpec::bottom_up(node.borrow_datamut());
            self.root = Some(node);
        } else {
            self.splay(SeekBySize::new(index));
            let mut root = self.root.take().unwrap();
            let left = unsafe { root.borrow_mut().left_mut().take() };
            if let Some(left) = left {
                unsafe { node.borrow_mut().left_mut().set(left) };
            }
            ImplicitSplayTreeSpec::bottom_up(root.borrow_datamut());
            unsafe { node.borrow_mut().right_mut().set(root) };
            ImplicitSplayTreeSpec::bottom_up(node.borrow_datamut());
            self.root = Some(node);
        }
        self.length += 1;
    }

    pub fn remove(&mut self, index: usize) -> Option<T::Key> {
        if index >= self.length {
            return None;
        }
        self.splay(SeekBySize::new(index));
        let mut node = self.root.take().unwrap();
        ImplicitSplayTreeSpec::top_down(node.borrow_datamut());
        let left = unsafe { node.borrow_mut().left_mut().take() };
        let right = unsafe { node.borrow_mut().right_mut().take() };
        self.root = ImplicitSplayTreeSpec::merge(left, right);
        self.length -= 1;
        let data = unsafe { node.into_dying().into_data(self.allocator.deref_mut()) };
        Some(data.value.key)
    }

crates/competitive/src/data_structure/splay_tree.rs (line 260)

    pub fn insert(&mut self, key: K, value: V) -> Option<V>
    where
        K: Ord,
    {
        let ordering = self.splay_by_key(&key);
        if matches!(ordering, Some(Ordering::Equal)) {
            return Some(replace(
                &mut self
                    .root
                    .as_mut()
                    .unwrap()
                    .borrow_datamut()
                    .data_mut()
                    .value,
                value,
            ));
        }
        let mut node = BstRoot::from_data(
            SplayTreeData {
                key,
                value,
                size: 1,
            },
            self.allocator.deref_mut(),
        );
        if let Some(mut root) = self.root.take() {
            match ordering.unwrap() {
                Ordering::Greater => {
                    let left = unsafe { root.borrow_mut().left_mut().take() };
                    if let Some(left) = left {
                        unsafe { node.borrow_mut().left_mut().set(left) };
                    }
                    SplayTreeSpec::bottom_up(root.borrow_datamut());
                    unsafe { node.borrow_mut().right_mut().set(root) };
                }
                Ordering::Less => {
                    let right = unsafe { root.borrow_mut().right_mut().take() };
                    if let Some(right) = right {
                        unsafe { node.borrow_mut().right_mut().set(right) };
                    }
                    SplayTreeSpec::bottom_up(root.borrow_datamut());
                    unsafe { node.borrow_mut().left_mut().set(root) };
                }
                Ordering::Equal => unreachable!(),
            }
            SplayTreeSpec::bottom_up(node.borrow_datamut());
        }
        self.root = Some(node);
        self.length += 1;
        None
    }

    pub fn remove<Q>(&mut self, key: &Q) -> Option<V>
    where
        K: Borrow<Q>,
        Q: Ord + ?Sized,
    {
        if !matches!(self.splay_by_key(key)?, Ordering::Equal) {
            return None;
        }
        Some(self.remove_root().1)
    }

    pub fn remove_at(&mut self, index: usize) -> Option<(K, V)> {
        if index >= self.length {
            return None;
        }
        self.splay_by_size(index);
        Some(self.remove_root())
    }

    fn remove_root(&mut self) -> (K, V) {
        let mut node = self.root.take().unwrap();
        let left = unsafe { node.borrow_mut().left_mut().take() };
        let right = unsafe { node.borrow_mut().right_mut().take() };
        self.root = SplayTreeSpec::merge(left, right);
        self.length -= 1;
        let data = unsafe { node.into_dying().into_data(self.allocator.deref_mut()) };
        (data.key, data.value)
    }

crates/competitive/src/data_structure/splay_operations.rs (line 279)

pub fn splay<Spec, Data, Seeker>(
    root: BstRoot<Spec>,
    mut seeker: Seeker,
) -> (Ordering, BstRoot<Spec>)
where
    Spec: BstSpec<Data = Data, Parent = WithNoParent<Data>>,
    Seeker: BstSeeker<Spec = Spec>,
{
    let mut root = root;
    let mut left_subtree = None;
    let mut right_subtree = None;
    let mut left_entry = &mut left_subtree;
    let mut right_entry = &mut right_subtree;
    let mut inline_stack = [None; 24];
    let mut inline_len = 0;
    let mut overflow_stack = vec![];

    macro_rules! push_node {
        ($node:expr) => {
            if inline_len < inline_stack.len() {
                inline_stack[inline_len] = Some($node);
                inline_len += 1;
            } else {
                overflow_stack.push($node);
            }
        };
    }

    macro_rules! add {
        (@left $node:ident) => {
            *left_entry = Some($node.node);
            push_node!($node.node);
            left_entry = unsafe { &mut $node.node.as_mut().child[1] };
        };
        (@right $node:ident) => {
            *right_entry = Some($node.node);
            push_node!($node.node);
            right_entry = unsafe { &mut $node.node.as_mut().child[0] };
        };
    }

    let root_ordering = loop {
        Spec::top_down(root.borrow_datamut());
        match seeker.bst_seek(root.reborrow()) {
            Ordering::Greater => {
                let Some(mut child) = (unsafe { root.borrow_mut().left_mut().take() }) else {
                    break Ordering::Greater;
                };
                Spec::top_down(child.borrow_datamut());
                match seeker.bst_seek(child.reborrow()) {
                    Ordering::Greater => {
                        let Some(mut grandchild) =
                            (unsafe { child.borrow_mut().left_mut().take() })
                        else {
                            add!(@right root);
                            root = child;
                            break Ordering::Greater;
                        };
                        Spec::top_down(grandchild.borrow_datamut());
                        let child_right = unsafe { child.borrow_mut().right_mut().take() };
                        if let Some(child_right) = child_right {
                            unsafe { root.borrow_mut().left_mut().set(child_right) };
                        }
                        Spec::bottom_up(root.borrow_datamut());
                        unsafe { child.borrow_mut().right_mut().set(root) };
                        add!(@right child);
                        root = grandchild;
                    }
                    Ordering::Equal => {
                        add!(@right root);
                        root = child;
                        break Ordering::Equal;
                    }
                    Ordering::Less => {
                        let Some(mut grandchild) =
                            (unsafe { child.borrow_mut().right_mut().take() })
                        else {
                            add!(@right root);
                            root = child;
                            break Ordering::Less;
                        };
                        Spec::top_down(grandchild.borrow_datamut());
                        add!(@right root);
                        add!(@left child);
                        root = grandchild;
                    }
                }
            }
            Ordering::Equal => break Ordering::Equal,
            Ordering::Less => {
                let Some(mut child) = (unsafe { root.borrow_mut().right_mut().take() }) else {
                    break Ordering::Less;
                };
                Spec::top_down(child.borrow_datamut());
                match seeker.bst_seek(child.reborrow()) {
                    Ordering::Greater => {
                        let Some(mut grandchild) =
                            (unsafe { child.borrow_mut().left_mut().take() })
                        else {
                            add!(@left root);
                            root = child;
                            break Ordering::Greater;
                        };
                        Spec::top_down(grandchild.borrow_datamut());
                        add!(@left root);
                        add!(@right child);
                        root = grandchild;
                    }
                    Ordering::Equal => {
                        add!(@left root);
                        root = child;
                        break Ordering::Equal;
                    }
                    Ordering::Less => {
                        let Some(mut grandchild) =
                            (unsafe { child.borrow_mut().right_mut().take() })
                        else {
                            add!(@left root);
                            root = child;
                            break Ordering::Less;
                        };
                        Spec::top_down(grandchild.borrow_datamut());
                        let child_left = unsafe { child.borrow_mut().left_mut().take() };
                        if let Some(child_left) = child_left {
                            unsafe { root.borrow_mut().right_mut().set(child_left) };
                        }
                        Spec::bottom_up(root.borrow_datamut());
                        unsafe { child.borrow_mut().left_mut().set(root) };
                        add!(@left child);
                        root = grandchild;
                    }
                }
            }
        }
    };

    *left_entry = unsafe { root.borrow_mut().left_mut().take() }.map(|node| node.node);
    *right_entry = unsafe { root.borrow_mut().right_mut().take() }.map(|node| node.node);
    unsafe {
        root.node.as_mut().child[0] = left_subtree;
        root.node.as_mut().child[1] = right_subtree;
        while let Some(node) = overflow_stack.pop() {
            Spec::bottom_up(BstRoot::new(node).borrow_datamut());
        }
        while inline_len > 0 {
            inline_len -= 1;
            let node = inline_stack[inline_len].unwrap_unchecked();
            Spec::bottom_up(BstRoot::new(node).borrow_datamut());
        }
    }
    Spec::bottom_up(root.borrow_datamut());
    (root_ordering, root)
}

#[inline]
pub fn merge<Spec, Data>(
    left: Option<BstRoot<Spec>>,
    right: Option<BstRoot<Spec>>,
) -> Option<BstRoot<Spec>>
where
    Spec: BstSpec<Data = Data, Parent = WithNoParent<Data>>,
{
    match (left, right) {
        (None, None) => None,
        (None, Some(root)) | (Some(root), None) => Some(root),
        (Some(left), Some(mut right)) if right.reborrow().left().descend().is_err() => {
            Spec::top_down(right.borrow_datamut());
            unsafe { right.borrow_mut().left_mut().set(left) };
            Spec::bottom_up(right.borrow_datamut());
            Some(right)
        }
        (Some(left), Some(right)) => {
            let (_, mut root) = splay(left, SeekRight::default());
            unsafe { root.borrow_mut().right_mut().set(right) };
            Spec::bottom_up(root.borrow_datamut());
            Some(root)
        }
    }
}

#[inline]
pub fn split<Spec, Data, Seeker>(
    root: Option<BstRoot<Spec>>,
    seeker: Seeker,
    equal_side: EqualSide,
) -> (Option<BstRoot<Spec>>, Option<BstRoot<Spec>>)
where
    Spec: BstSpec<Data = Data, Parent = WithNoParent<Data>>,
    Seeker: BstSeeker<Spec = Spec>,
{
    let Some(root) = root else {
        return (None, None);
    };
    let (ordering, mut root) = splay(root, seeker);
    if equal_side.goes_left(ordering) {
        let right = unsafe { root.borrow_mut().right_mut().take() };
        Spec::bottom_up(root.borrow_datamut());
        (Some(root), right)
    } else {
        let left = unsafe { root.borrow_mut().left_mut().take() };
        Spec::bottom_up(root.borrow_datamut());
        (left, Some(root))
    }
}

pub fn right_mut(&mut self) -> BstEdgeHandle<BstNodeRef<Mut<'_>, Spec>, Right>

Examples found in repository

crates/competitive/src/data_structure/binary_search_tree/node.rs (line 186)

    pub unsafe fn remove_root<Spec>(
        root: &mut Option<BstRoot<Spec>>,
    ) -> Option<BstNodeRef<marker::Owned, Spec>>
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        let mut node = root.take()?;
        unsafe {
            let left = node.borrow_mut().left_mut().take();
            let right = node.borrow_mut().right_mut().take();
            *root = Spec::merge(left, right);
            Spec::bottom_up(node.borrow_datamut());
            Some(node)
        }
    }

    pub unsafe fn remove_not_root<Spec>(
        mut node: BstNodeRef<marker::Mut<'_>, Spec>,
    ) -> BstNodeRef<marker::Owned, Spec>
    where
        Spec: BstSpec<Data = Data, Parent = Self>,
    {
        assert!(!Self::is_root(node.reborrow()));
        unsafe {
            let left = node.left_mut().take();
            let right = node.right_mut().take();
            let merged = Spec::merge(left, right);
            let node_inner = node.node;
            let mut parent = node.ascend().unwrap_unchecked();
            let mut node = if let Some(merged) = merged {
                let node = if parent
                    .reborrow()
                    .left()
                    .descend()
                    .is_ok_and(|n| n.node == node_inner)
                {
                    parent.left_mut().replace(merged)
                } else {
                    parent.right_mut().replace(merged)
                };
                Self::resolve_bottom_up(parent.reborrow_datamut());
                node.unwrap_unchecked()
            } else {
                let node = if parent
                    .reborrow()
                    .left()
                    .descend()
                    .is_ok_and(|n| n.node == node_inner)
                {
                    parent.left_mut().take()
                } else {
                    parent.right_mut().take()
                };
                Self::resolve_bottom_up(parent.reborrow_datamut());
                node.unwrap_unchecked()
            };
            Spec::bottom_up(node.borrow_datamut());
            node
        }
    }

crates/competitive/src/data_structure/implicit_splay_tree.rs (line 338)

    pub fn insert(&mut self, index: usize, key: T::Key) {
        assert!(index <= self.length);
        let mut node = self.node(key);
        if self.root.is_none() {
            self.root = Some(node);
        } else if index == self.length {
            self.splay(SeekBySize::new(index));
            unsafe { node.borrow_mut().left_mut().set(self.root.take().unwrap()) };
            ImplicitSplayTreeSpec::bottom_up(node.borrow_datamut());
            self.root = Some(node);
        } else {
            self.splay(SeekBySize::new(index));
            let mut root = self.root.take().unwrap();
            let left = unsafe { root.borrow_mut().left_mut().take() };
            if let Some(left) = left {
                unsafe { node.borrow_mut().left_mut().set(left) };
            }
            ImplicitSplayTreeSpec::bottom_up(root.borrow_datamut());
            unsafe { node.borrow_mut().right_mut().set(root) };
            ImplicitSplayTreeSpec::bottom_up(node.borrow_datamut());
            self.root = Some(node);
        }
        self.length += 1;
    }

    pub fn remove(&mut self, index: usize) -> Option<T::Key> {
        if index >= self.length {
            return None;
        }
        self.splay(SeekBySize::new(index));
        let mut node = self.root.take().unwrap();
        ImplicitSplayTreeSpec::top_down(node.borrow_datamut());
        let left = unsafe { node.borrow_mut().left_mut().take() };
        let right = unsafe { node.borrow_mut().right_mut().take() };
        self.root = ImplicitSplayTreeSpec::merge(left, right);
        self.length -= 1;
        let data = unsafe { node.into_dying().into_data(self.allocator.deref_mut()) };
        Some(data.value.key)
    }

crates/competitive/src/data_structure/splay_tree.rs (line 265)

    pub fn insert(&mut self, key: K, value: V) -> Option<V>
    where
        K: Ord,
    {
        let ordering = self.splay_by_key(&key);
        if matches!(ordering, Some(Ordering::Equal)) {
            return Some(replace(
                &mut self
                    .root
                    .as_mut()
                    .unwrap()
                    .borrow_datamut()
                    .data_mut()
                    .value,
                value,
            ));
        }
        let mut node = BstRoot::from_data(
            SplayTreeData {
                key,
                value,
                size: 1,
            },
            self.allocator.deref_mut(),
        );
        if let Some(mut root) = self.root.take() {
            match ordering.unwrap() {
                Ordering::Greater => {
                    let left = unsafe { root.borrow_mut().left_mut().take() };
                    if let Some(left) = left {
                        unsafe { node.borrow_mut().left_mut().set(left) };
                    }
                    SplayTreeSpec::bottom_up(root.borrow_datamut());
                    unsafe { node.borrow_mut().right_mut().set(root) };
                }
                Ordering::Less => {
                    let right = unsafe { root.borrow_mut().right_mut().take() };
                    if let Some(right) = right {
                        unsafe { node.borrow_mut().right_mut().set(right) };
                    }
                    SplayTreeSpec::bottom_up(root.borrow_datamut());
                    unsafe { node.borrow_mut().left_mut().set(root) };
                }
                Ordering::Equal => unreachable!(),
            }
            SplayTreeSpec::bottom_up(node.borrow_datamut());
        }
        self.root = Some(node);
        self.length += 1;
        None
    }

    pub fn remove<Q>(&mut self, key: &Q) -> Option<V>
    where
        K: Borrow<Q>,
        Q: Ord + ?Sized,
    {
        if !matches!(self.splay_by_key(key)?, Ordering::Equal) {
            return None;
        }
        Some(self.remove_root().1)
    }

    pub fn remove_at(&mut self, index: usize) -> Option<(K, V)> {
        if index >= self.length {
            return None;
        }
        self.splay_by_size(index);
        Some(self.remove_root())
    }

    fn remove_root(&mut self) -> (K, V) {
        let mut node = self.root.take().unwrap();
        let left = unsafe { node.borrow_mut().left_mut().take() };
        let right = unsafe { node.borrow_mut().right_mut().take() };
        self.root = SplayTreeSpec::merge(left, right);
        self.length -= 1;
        let data = unsafe { node.into_dying().into_data(self.allocator.deref_mut()) };
        (data.key, data.value)
    }

crates/competitive/src/data_structure/splay_operations.rs (line 293)

pub fn splay<Spec, Data, Seeker>(
    root: BstRoot<Spec>,
    mut seeker: Seeker,
) -> (Ordering, BstRoot<Spec>)
where
    Spec: BstSpec<Data = Data, Parent = WithNoParent<Data>>,
    Seeker: BstSeeker<Spec = Spec>,
{
    let mut root = root;
    let mut left_subtree = None;
    let mut right_subtree = None;
    let mut left_entry = &mut left_subtree;
    let mut right_entry = &mut right_subtree;
    let mut inline_stack = [None; 24];
    let mut inline_len = 0;
    let mut overflow_stack = vec![];

    macro_rules! push_node {
        ($node:expr) => {
            if inline_len < inline_stack.len() {
                inline_stack[inline_len] = Some($node);
                inline_len += 1;
            } else {
                overflow_stack.push($node);
            }
        };
    }

    macro_rules! add {
        (@left $node:ident) => {
            *left_entry = Some($node.node);
            push_node!($node.node);
            left_entry = unsafe { &mut $node.node.as_mut().child[1] };
        };
        (@right $node:ident) => {
            *right_entry = Some($node.node);
            push_node!($node.node);
            right_entry = unsafe { &mut $node.node.as_mut().child[0] };
        };
    }

    let root_ordering = loop {
        Spec::top_down(root.borrow_datamut());
        match seeker.bst_seek(root.reborrow()) {
            Ordering::Greater => {
                let Some(mut child) = (unsafe { root.borrow_mut().left_mut().take() }) else {
                    break Ordering::Greater;
                };
                Spec::top_down(child.borrow_datamut());
                match seeker.bst_seek(child.reborrow()) {
                    Ordering::Greater => {
                        let Some(mut grandchild) =
                            (unsafe { child.borrow_mut().left_mut().take() })
                        else {
                            add!(@right root);
                            root = child;
                            break Ordering::Greater;
                        };
                        Spec::top_down(grandchild.borrow_datamut());
                        let child_right = unsafe { child.borrow_mut().right_mut().take() };
                        if let Some(child_right) = child_right {
                            unsafe { root.borrow_mut().left_mut().set(child_right) };
                        }
                        Spec::bottom_up(root.borrow_datamut());
                        unsafe { child.borrow_mut().right_mut().set(root) };
                        add!(@right child);
                        root = grandchild;
                    }
                    Ordering::Equal => {
                        add!(@right root);
                        root = child;
                        break Ordering::Equal;
                    }
                    Ordering::Less => {
                        let Some(mut grandchild) =
                            (unsafe { child.borrow_mut().right_mut().take() })
                        else {
                            add!(@right root);
                            root = child;
                            break Ordering::Less;
                        };
                        Spec::top_down(grandchild.borrow_datamut());
                        add!(@right root);
                        add!(@left child);
                        root = grandchild;
                    }
                }
            }
            Ordering::Equal => break Ordering::Equal,
            Ordering::Less => {
                let Some(mut child) = (unsafe { root.borrow_mut().right_mut().take() }) else {
                    break Ordering::Less;
                };
                Spec::top_down(child.borrow_datamut());
                match seeker.bst_seek(child.reborrow()) {
                    Ordering::Greater => {
                        let Some(mut grandchild) =
                            (unsafe { child.borrow_mut().left_mut().take() })
                        else {
                            add!(@left root);
                            root = child;
                            break Ordering::Greater;
                        };
                        Spec::top_down(grandchild.borrow_datamut());
                        add!(@left root);
                        add!(@right child);
                        root = grandchild;
                    }
                    Ordering::Equal => {
                        add!(@left root);
                        root = child;
                        break Ordering::Equal;
                    }
                    Ordering::Less => {
                        let Some(mut grandchild) =
                            (unsafe { child.borrow_mut().right_mut().take() })
                        else {
                            add!(@left root);
                            root = child;
                            break Ordering::Less;
                        };
                        Spec::top_down(grandchild.borrow_datamut());
                        let child_left = unsafe { child.borrow_mut().left_mut().take() };
                        if let Some(child_left) = child_left {
                            unsafe { root.borrow_mut().right_mut().set(child_left) };
                        }
                        Spec::bottom_up(root.borrow_datamut());
                        unsafe { child.borrow_mut().left_mut().set(root) };
                        add!(@left child);
                        root = grandchild;
                    }
                }
            }
        }
    };

    *left_entry = unsafe { root.borrow_mut().left_mut().take() }.map(|node| node.node);
    *right_entry = unsafe { root.borrow_mut().right_mut().take() }.map(|node| node.node);
    unsafe {
        root.node.as_mut().child[0] = left_subtree;
        root.node.as_mut().child[1] = right_subtree;
        while let Some(node) = overflow_stack.pop() {
            Spec::bottom_up(BstRoot::new(node).borrow_datamut());
        }
        while inline_len > 0 {
            inline_len -= 1;
            let node = inline_stack[inline_len].unwrap_unchecked();
            Spec::bottom_up(BstRoot::new(node).borrow_datamut());
        }
    }
    Spec::bottom_up(root.borrow_datamut());
    (root_ordering, root)
}

#[inline]
pub fn merge<Spec, Data>(
    left: Option<BstRoot<Spec>>,
    right: Option<BstRoot<Spec>>,
) -> Option<BstRoot<Spec>>
where
    Spec: BstSpec<Data = Data, Parent = WithNoParent<Data>>,
{
    match (left, right) {
        (None, None) => None,
        (None, Some(root)) | (Some(root), None) => Some(root),
        (Some(left), Some(mut right)) if right.reborrow().left().descend().is_err() => {
            Spec::top_down(right.borrow_datamut());
            unsafe { right.borrow_mut().left_mut().set(left) };
            Spec::bottom_up(right.borrow_datamut());
            Some(right)
        }
        (Some(left), Some(right)) => {
            let (_, mut root) = splay(left, SeekRight::default());
            unsafe { root.borrow_mut().right_mut().set(right) };
            Spec::bottom_up(root.borrow_datamut());
            Some(root)
        }
    }
}

#[inline]
pub fn split<Spec, Data, Seeker>(
    root: Option<BstRoot<Spec>>,
    seeker: Seeker,
    equal_side: EqualSide,
) -> (Option<BstRoot<Spec>>, Option<BstRoot<Spec>>)
where
    Spec: BstSpec<Data = Data, Parent = WithNoParent<Data>>,
    Seeker: BstSeeker<Spec = Spec>,
{
    let Some(root) = root else {
        return (None, None);
    };
    let (ordering, mut root) = splay(root, seeker);
    if equal_side.goes_left(ordering) {
        let right = unsafe { root.borrow_mut().right_mut().take() };
        Spec::bottom_up(root.borrow_datamut());
        (Some(root), right)
    } else {
        let left = unsafe { root.borrow_mut().left_mut().take() };
        Spec::bottom_up(root.borrow_datamut());
        (left, Some(root))
    }
}

impl<'a, Spec> BstNodeRef<Mut<'a>, Spec>

where Spec: BstSpec<Data: 'a>,

pub fn dormant(self) -> BstNodeRef<DormantMut, Spec>

impl<Spec> BstNodeRef<DormantMut, Spec>

where Spec: BstSpec,

pub unsafe fn awaken<'a>(self) -> BstNodeRef<Mut<'a>, Spec>

impl<Spec> BstNodeRef<Dying, Spec>

where Spec: BstSpec,

pub unsafe fn into_data<A>(self, allocator: &mut A) -> Spec::Data

where A: Allocator<BstNode<Spec::Data, Spec::Parent>>,

Examples found in repository

crates/competitive/src/data_structure/splay_tree.rs (line 309)

    fn remove_root(&mut self) -> (K, V) {
        let mut node = self.root.take().unwrap();
        let left = unsafe { node.borrow_mut().left_mut().take() };
        let right = unsafe { node.borrow_mut().right_mut().take() };
        self.root = SplayTreeSpec::merge(left, right);
        self.length -= 1;
        let data = unsafe { node.into_dying().into_data(self.allocator.deref_mut()) };
        (data.key, data.value)
    }

crates/competitive/src/data_structure/implicit_splay_tree.rs (line 356)

    pub fn remove(&mut self, index: usize) -> Option<T::Key> {
        if index >= self.length {
            return None;
        }
        self.splay(SeekBySize::new(index));
        let mut node = self.root.take().unwrap();
        ImplicitSplayTreeSpec::top_down(node.borrow_datamut());
        let left = unsafe { node.borrow_mut().left_mut().take() };
        let right = unsafe { node.borrow_mut().right_mut().take() };
        self.root = ImplicitSplayTreeSpec::merge(left, right);
        self.length -= 1;
        let data = unsafe { node.into_dying().into_data(self.allocator.deref_mut()) };
        Some(data.value.key)
    }

crates/competitive/src/data_structure/treap.rs (line 394)

    pub fn remove(&mut self, node_id: BstNodeId<TreapSpec<M, L>>) -> Option<(M::Key, L::Key)> {
        if !self.node_id_manager.contains(&node_id) {
            return None;
        }
        unsafe {
            WithParent::resolve_top_down::<TreapSpec<M, L>>(
                node_id.reborrow_datamut(&mut self.root),
            );
            let node = if WithParent::is_root(node_id.reborrow(&self.root)) {
                WithParent::remove_root(&mut self.root).unwrap_unchecked()
            } else {
                WithParent::remove_not_root(node_id.reborrow_mut(&mut self.root))
            };
            self.node_id_manager.unregister(node_id);
            let data = node.into_dying().into_data(self.allocator.deref_mut());
            Some((data.key.key, data.value.key))
        }
    }

crates/competitive/src/data_structure/implicit_treap.rs (line 460)

    pub fn remove(&mut self, index: usize) -> Option<T::Key> {
        if index >= self.length {
            return None;
        }
        let mid;
        if index == 0 {
            let (left, right) = ImplicitTreapSpec::<T>::split(
                self.root.take(),
                SeekBySize::new(1),
                EqualSide::Right,
            );
            mid = left;
            self.root = right;
        } else if index + 1 == self.length {
            let (left, right) = ImplicitTreapSpec::<T>::split(
                self.root.take(),
                SeekBySize::new(index),
                EqualSide::Right,
            );
            mid = right;
            self.root = left;
        } else {
            let (left, rest) = ImplicitTreapSpec::<T>::split(
                self.root.take(),
                SeekBySize::new(index),
                EqualSide::Right,
            );
            let (middle, right) =
                ImplicitTreapSpec::<T>::split(rest, SeekBySize::new(1), EqualSide::Right);
            mid = middle;
            self.root = ImplicitTreapSpec::<T>::merge(left, right);
        }
        self.length -= 1;
        let mut node = mid.unwrap();
        ImplicitTreapSpec::<T>::top_down(node.borrow_datamut());
        let data = unsafe { node.into_dying().into_data(self.allocator.deref_mut()) };
        Some(data.value.key)
    }

pub unsafe fn drop_all<A>(self, allocator: &mut A)

where A: Allocator<BstNode<Spec::Data, Spec::Parent>>,

Examples found in repository

crates/competitive/src/data_structure/implicit_splay_tree.rs (line 207)

    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }

crates/competitive/src/data_structure/implicit_treap.rs (line 253)

    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }

crates/competitive/src/data_structure/splay_tree.rs (line 157)

    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }

crates/competitive/src/data_structure/treap.rs (line 268)

    fn drop(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            ManuallyDrop::drop(&mut self.allocator);
        }
    }
}

impl<M, L> Treap<M, L>
where
    M: MonoidAct<Key: Ord>,
    L: LazyMapMonoid,
{
    pub fn new() -> Self {
        Self::default()
    }
}

impl<M, L, A> Treap<M, L, A>
where
    M: MonoidAct<Key: Ord>,
    L: LazyMapMonoid,
    A: Allocator<TreapNode<M, L>>,
{
    pub fn len(&self) -> usize {
        self.node_id_manager.len()
    }

    pub fn is_empty(&self) -> bool {
        self.node_id_manager.is_empty()
    }

    pub fn clear(&mut self) {
        unsafe {
            if let Some(root) = self.root.take() {
                root.into_dying().drop_all(self.allocator.deref_mut());
            }
            self.node_id_manager.clear();
        }
    }

Trait Implementations

impl<'a, Spec> Clone for BstNodeRef<Immut<'a>, Spec>

where Spec: BstSpec<Data: 'a>,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, Spec> Copy for BstNodeRef<Immut<'a>, Spec>

where Spec: BstSpec<Data: 'a>,