use std::marker::PhantomData;
use crate::{
context::{ContextGuard, LockingIterator, LockingTuple},
lockable::{Lockable, RawLock, Sharable},
ThreadKey,
};
impl<'c, A, B, O> LockingTuple<'c, A, B, O> {
fn transmute<C>(self) -> LockingTuple<'c, C, B, O> {
LockingTuple {
_lockable: PhantomData,
key: self.key,
tuple: self.tuple,
outer: self.outer,
}
}
}
// Some day I need to invent variadic generics for Rust to make this easier for
// myself
macro_rules! lock_impl {
($self: expr, $field: tt) => {
unsafe {
$self.tuple.$field.raw_write();
(
ContextGuard {
_key: &$self.key,
guard: $self.tuple.$field.guard(),
},
$self.transmute(),
)
}
};
}
macro_rules! try_lock_impl {
($self: expr, $field: tt) => {
unsafe {
if $self.tuple.$field.raw_try_write() {
Ok((
ContextGuard {
_key: $self.key,
guard: $self.tuple.$field.guard(),
},
$self.transmute(),
))
} else {
Err($self)
}
}
};
}
macro_rules! lock_mut_impl {
($self: expr, $field: tt) => {
unsafe {
$self.tuple.$field.raw_write();
ContextGuard {
_key: $self.key,
guard: $self.tuple.$field.guard(),
}
}
};
}
macro_rules! try_lock_mut_impl {
($self: expr, $field: tt) => {
unsafe {
if $self.tuple.$field.raw_try_write() {
Some(ContextGuard {
_key: $self.key,
guard: $self.tuple.$field.guard(),
})
} else {
None
}
}
};
}
macro_rules! read_impl {
($self: expr, $field: tt) => {
unsafe {
$self.tuple.$field.raw_read();
(
ContextGuard {
_key: &$self.key,
guard: $self.tuple.$field.read_guard(),
},
$self.transmute(),
)
}
};
}
macro_rules! try_read_impl {
($self: expr, $field: tt) => {
unsafe {
if $self.tuple.$field.raw_try_read() {
Ok((
ContextGuard {
_key: $self.key,
guard: $self.tuple.$field.read_guard(),
},
$self.transmute(),
))
} else {
Err($self)
}
}
};
}
macro_rules! read_mut_impl {
($self: expr, $field: tt) => {
unsafe {
$self.tuple.$field.raw_read();
ContextGuard {
_key: $self.key,
guard: $self.tuple.$field.read_guard(),
}
}
};
}
macro_rules! try_read_mut_impl {
($self: expr, $field: tt) => {
unsafe {
if $self.tuple.$field.raw_try_read() {
Some(ContextGuard {
_key: $self.key,
guard: $self.tuple.$field.read_guard(),
})
} else {
None
}
}
};
}
macro_rules! recurse_impl {
($self: expr, $field: tt) => {
LockingTuple {
_lockable: PhantomData,
key: $self.key,
tuple: &$self.tuple.$field,
outer: $self.transmute(),
}
};
}
macro_rules! recurse_iter_impl {
($self: expr, $field: tt) => {
LockingIterator {
key: $self.key,
iterator: $self.tuple.$field.into_iter(),
outer: $self.transmute(),
}
};
}
// I created these types to help reduce the complexity of the method return
// types. But now I've added so much functionality that these types are just as
// complicates. Oh well.
type LockReturn<'a, 'context, Guarded, L, C, O> = (
ContextGuard<'a, <Guarded as Lockable>::Guard<'a>, ThreadKey>,
LockingTuple<'context, L, C, O>,
);
type TryLockReturn<'a, 'context, Guarded, L, C, O, This> =
Result<LockReturn<'a, 'context, Guarded, L, C, O>, This>;
type ReadReturn<'a, 'context, Guarded, L, C, O> = (
ContextGuard<'a, <Guarded as Sharable>::ReadGuard<'a>, ThreadKey>,
LockingTuple<'context, L, C, O>,
);
type TryReadReturn<'a, 'context, Guarded, L, C, O, This> =
Result<ReadReturn<'a, 'context, Guarded, L, C, O>, This>;
type RecurseReturn<'context, Inner, L, C, O> =
LockingTuple<'context, Inner, Inner, LockingTuple<'context, L, C, O>>;
type RecurseIterReturn<'context, Inner, L, C, O> = LockingIterator<
'context,
<&'context Inner as IntoIterator>::IntoIter,
LockingTuple<'context, L, C, O>,
>;
impl<T, C, Outer> LockingTuple<'_, T, C, Outer> {
/// Exit out of the current scope of the locking tuple into the parent.
// Luckily, this only needs one implementation
pub fn exit(self) -> Outer {
self.outer
}
}
impl<'context, A: RawLock + Lockable, Outer> LockingTuple<'context, (A,), (A,), Outer> {
/// Lock the first element, and return a new tuple where the first element
/// is inaccessible.
#[must_use]
pub fn lock_0<'a>(self) -> LockReturn<'a, 'context, A, ((),), (A,), Outer>
where
'context: 'a,
{
lock_impl!(self, 0)
}
/// Attempts to lock the first element without blocking, and return a new tuple
/// where the first element is inaccessible.
///
/// # Errors
///
/// If the element is already locked, `Err` is returned with the original
/// tuple.
pub fn try_lock_0<'a>(self) -> TryLockReturn<'a, 'context, A, ((),), (A,), Outer, Self>
where
'context: 'a,
{
try_lock_impl!(self, 0)
}
/// Lock the first element. The tuple becomes unusable until the returned
/// guard is dropped.
#[must_use]
pub fn lock_mut_0(&mut self) -> ContextGuard<'_, A::Guard<'_>, ThreadKey> {
lock_mut_impl!(self, 0)
}
/// Attempts to lock the first element without blocking. If successful, the
/// tuple becomes unusable until the returned guard is dropped. If the element
/// is already locked, `None` is returned.
#[must_use]
pub fn try_lock_mut_0(&mut self) -> Option<ContextGuard<'_, A::Guard<'_>, ThreadKey>> {
try_lock_mut_impl!(self, 0)
}
}
impl<'context, A: RawLock + Sharable, Outer> LockingTuple<'context, (A,), (A,), Outer> {
/// Acquire a shared lock to the first element, and return a new tuple where
/// the first element is inaccessible.
#[must_use]
pub fn read_0<'a>(self) -> ReadReturn<'a, 'context, A, ((),), (A,), Outer>
where
'context: 'a,
{
read_impl!(self, 0)
}
/// Attempts to acquire a shared lock the first element without blocking, and
/// return a new tuple where the first element is inaccessible.
///
/// # Errors
///
/// If the element is already exclusively locked, `Err` is returned with the original
/// tuple.
pub fn try_read_0<'a>(self) -> TryReadReturn<'a, 'context, A, ((),), (A,), Outer, Self>
where
'context: 'a,
{
try_read_impl!(self, 0)
}
/// Acquire a shared lock to the first element. The tuple becomes unusable
/// until the returned guard is dropped.
#[must_use]
pub fn read_mut_0(&mut self) -> ContextGuard<'_, A::ReadGuard<'_>, ThreadKey> {
read_mut_impl!(self, 0)
}
/// Attempts to acquire a shared lock the first element without blocking. If
/// successful, the tuple becomes unusable until the returned guard is
/// dropped. If the element is already exclusively locked, `None` is returned.
#[must_use]
pub fn try_read_mut_0(&mut self) -> Option<ContextGuard<'_, A::ReadGuard<'_>, ThreadKey>> {
try_read_mut_impl!(self, 0)
}
}
impl<'context, A, O> LockingTuple<'context, (A,), (A,), O> {
/// Consume the tuple, and return the first element as a new tuple.
#[must_use]
pub fn recurse_0(self) -> RecurseReturn<'context, A, ((),), (A,), O> {
recurse_impl!(self, 0)
}
/// Consume the tuple, and return the first element as a locking iterator.
pub fn recurse_0_iter(self) -> RecurseIterReturn<'context, A, ((),), (A,), O>
where
&'context A: IntoIterator,
{
recurse_iter_impl!(self, 0)
}
}
impl<'context, A: RawLock + Lockable, B, B0, O> LockingTuple<'context, (A, B), (A, B0), O> {
/// Lock the first element, and return a new tuple where the first element
/// is inaccessible.
#[must_use]
pub fn lock_0<'a>(self) -> LockReturn<'a, 'context, A, ((), B), (A, B0), O>
where
'context: 'a,
{
lock_impl!(self, 0)
}
/// Lock the first element. The tuple becomes unusable until the returned
/// guard is dropped.
#[must_use]
pub fn lock_mut_0(&mut self) -> ContextGuard<'_, A::Guard<'_>, ThreadKey> {
lock_mut_impl!(self, 0)
}
/// Attempts to lock the first element without blocking, and return a new tuple
/// where the first element is inaccessible.
///
/// # Errors
///
/// If the element is already locked, `Err` is returned with the original
/// tuple.
pub fn try_lock_0<'a>(self) -> TryLockReturn<'a, 'context, A, ((), B), (A, B0), O, Self>
where
'context: 'a,
{
try_lock_impl!(self, 0)
}
/// Attempts to lock the first element without blocking. If successful, the
/// tuple becomes unusable until the returned guard is dropped. If the element
/// is already locked, `None` is returned.
#[must_use]
pub fn try_lock_mut_0(&mut self) -> Option<ContextGuard<'_, A::Guard<'_>, ThreadKey>> {
try_lock_mut_impl!(self, 0)
}
}
impl<'context, A: RawLock + Sharable, B, B0, O> LockingTuple<'context, (A, B), (A, B0), O> {
/// Acquire a shared lock to the first element, and return a new tuple where
/// the first element is inaccessible.
#[must_use]
pub fn read_0<'a>(self) -> ReadReturn<'a, 'context, A, ((), B), (A, B0), O>
where
'context: 'a,
{
read_impl!(self, 0)
}
/// Attempts to acquire a shared lock the first element without blocking, and
/// return a new tuple where the first element is inaccessible.
///
/// # Errors
///
/// If the element is already exclusively locked, `Err` is returned with the original
/// tuple.
pub fn try_read_0<'a>(self) -> TryReadReturn<'a, 'context, A, ((), B), (A, B0), O, Self>
where
'context: 'a,
{
try_read_impl!(self, 0)
}
/// Acquire a shared lock to the first element. The tuple becomes unusable
/// until the returned guard is dropped.
#[must_use]
pub fn read_mut_0(&mut self) -> ContextGuard<'_, A::ReadGuard<'_>, ThreadKey> {
read_mut_impl!(self, 0)
}
/// Attempts to acquire a shared lock the first element without blocking. If
/// successful, the tuple becomes unusable until the returned guard is
/// dropped. If the element is already exclusively locked, `None` is returned.
#[must_use]
pub fn try_read_mut_0(&mut self) -> Option<ContextGuard<'_, A::ReadGuard<'_>, ThreadKey>> {
try_read_mut_impl!(self, 0)
}
}
impl<'context, A, B, B0, O> LockingTuple<'context, (A, B), (A, B0), O> {
/// Consume the tuple, and return the first element as a new tuple.
#[must_use]
pub fn recurse_0(self) -> RecurseReturn<'context, A, ((), B), (A, B0), O> {
recurse_impl!(self, 0)
}
/// Consume the tuple, and return the first element as a locking iterator.
pub fn recurse_0_iter(self) -> RecurseIterReturn<'context, A, ((), B), (A, B0), O>
where
&'context A: IntoIterator,
{
recurse_iter_impl!(self, 0)
}
}
impl<'context, A: Lockable + RawLock, B, O> LockingTuple<'context, (A, B), (A, B), O> {
/// Lock the first element, and return the second element as a new tuple.
#[must_use]
pub fn lock_and_recurse<'a>(
self,
) -> (
ContextGuard<'a, <A as Lockable>::Guard<'a>, ThreadKey>,
LockingTuple<'context, B, B, O>,
)
where
'context: 'a,
{
unsafe {
self.tuple.0.raw_write();
(
ContextGuard {
_key: self.key,
guard: self.tuple.0.guard(),
},
LockingTuple {
_lockable: PhantomData,
key: self.key,
tuple: &self.tuple.1,
outer: self.outer,
},
)
}
}
}
impl<'context, A, A0, B: RawLock + Lockable, O> LockingTuple<'context, (A, B), (A0, B), O> {
/// Lock the second element, and return a new tuple where the first and second
/// elements are inaccessible.
#[must_use]
pub fn lock_1<'a>(self) -> LockReturn<'a, 'context, B, ((), ()), (A0, B), O>
where
'context: 'a,
{
lock_impl!(self, 1)
}
/// Lock the second element. The tuple becomes unusable until the returned
/// guard is dropped.
#[must_use]
pub fn lock_mut_1(&mut self) -> ContextGuard<'_, B::Guard<'_>, ThreadKey> {
lock_mut_impl!(self, 1)
}
/// Attempts to lock the second element without blocking, and return a new tuple
/// where the first element is inaccessible.
///
/// # Errors
///
/// If the element is already locked, `Err` is returned with the original
/// tuple.
pub fn try_lock_1<'a>(self) -> TryLockReturn<'a, 'context, B, ((), ()), (A0, B), O, Self>
where
'context: 'a,
{
try_lock_impl!(self, 1)
}
/// Attempts to lock the second element without blocking. If successful, the
/// tuple becomes unusable until the returned guard is dropped. If the element
/// is already locked, `None` is returned.
#[must_use]
pub fn try_lock_mut_1(&mut self) -> Option<ContextGuard<'_, B::Guard<'_>, ThreadKey>> {
try_lock_mut_impl!(self, 1)
}
}
impl<'context, A, A0, B: RawLock + Sharable, O> LockingTuple<'context, (A, B), (A0, B), O> {
/// Acquire a shared lock to the second element, and return a new tuple where
/// the second element is inaccessible.
#[must_use]
pub fn read_1<'a>(self) -> ReadReturn<'a, 'context, B, ((), ()), (A0, B), O>
where
'context: 'a,
{
read_impl!(self, 1)
}
/// Attempts to acquire a shared lock the second element without blocking, and
/// return a new tuple where the second element is inaccessible.
///
/// # Errors
///
/// If the element is already exclusively locked, `Err` is returned with the original
/// tuple.
pub fn try_read_1<'a>(self) -> TryReadReturn<'a, 'context, B, ((), ()), (A0, B), O, Self>
where
'context: 'a,
{
try_read_impl!(self, 1)
}
/// Acquire a shared lock to the second element. The tuple becomes unusable
/// until the returned guard is dropped.
#[must_use]
pub fn read_mut_1(&mut self) -> ContextGuard<'_, B::ReadGuard<'_>, ThreadKey> {
read_mut_impl!(self, 1)
}
/// Attempts to acquire a shared lock the second element without blocking. If
/// successful, the tuple becomes unusable until the returned guard is
/// dropped. If the element is already exclusively locked, `None` is returned.
#[must_use]
pub fn try_read_mut_1(&mut self) -> Option<ContextGuard<'_, B::ReadGuard<'_>, ThreadKey>> {
try_read_mut_impl!(self, 1)
}
}
impl<'context, A, A0, B, O> LockingTuple<'context, (A, B), (A0, B), O> {
/// Consume the tuple, and return the second element as a new tuple.
#[must_use]
pub fn recurse_1(self) -> RecurseReturn<'context, B, ((), ()), (A0, B), O> {
recurse_impl!(self, 1)
}
/// Consume the tuple, and return the second element as a locking iterator.
pub fn recurse_1_iter(self) -> RecurseIterReturn<'context, B, (A, ()), (A0, B), O>
where
&'context B: IntoIterator,
{
recurse_iter_impl!(self, 1)
}
}
impl<'context, A: RawLock + Lockable, B, B0, C, C0, O>
LockingTuple<'context, (A, B, C), (A, B0, C0), O>
{
/// Lock the first element, and return a new tuple where the first element
/// is inaccessible.
#[must_use]
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn lock_0<'a>(self) -> LockReturn<'a, 'context, A, ((), B, C), (A, B0, C0), O>
where
'context: 'a,
{
lock_impl!(self, 0)
}
/// Lock the first element. The tuple becomes unusable until the returned
/// guard is dropped.
#[must_use]
pub fn lock_mut_0(&mut self) -> ContextGuard<'_, A::Guard<'_>, ThreadKey> {
lock_mut_impl!(self, 0)
}
/// Attempts to lock the first element without blocking. If successful, the
/// tuple becomes unusable until the returned guard is dropped. If the element
/// is already locked, `None` is returned.
#[must_use]
pub fn try_lock_mut_0(&mut self) -> Option<ContextGuard<'_, A::Guard<'_>, ThreadKey>> {
try_lock_mut_impl!(self, 0)
}
}
impl<'context, A: RawLock + Sharable, B, B0, C, C0, O>
LockingTuple<'context, (A, B, C), (A, B0, C0), O>
{
/// Acquire a shared lock to the first element, and return a new tuple where
/// the first element is inaccessible.
#[must_use]
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn read_0<'a>(self) -> ReadReturn<'a, 'context, A, ((), B, C), (A, B0, C0), O>
where
'context: 'a,
{
read_impl!(self, 0)
}
/// Acquire a shared lock to the first element. The tuple becomes unusable
/// until the returned guard is dropped.
#[must_use]
pub fn read_mut_0(&mut self) -> ContextGuard<'_, A::ReadGuard<'_>, ThreadKey> {
read_mut_impl!(self, 0)
}
/// Attempts to acquire a shared lock the first element without blocking. If
/// successful, the tuple becomes unusable until the returned guard is
/// dropped. If the element is already exclusively locked, `None` is returned.
#[must_use]
pub fn try_read_mut_0(&mut self) -> Option<ContextGuard<'_, A::ReadGuard<'_>, ThreadKey>> {
try_read_mut_impl!(self, 0)
}
}
impl<'context, A, B, B0, C, C0, O> LockingTuple<'context, (A, B, C), (A, B0, C0), O> {
/// Consume the tuple, and return the first element as a new tuple.
#[must_use]
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn recurse_0(self) -> RecurseReturn<'context, A, ((), B, C), (A, B0, C0), O> {
recurse_impl!(self, 0)
}
/// Consume the tuple, and return the first element as a locking iterator.
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn recurse_0_iter(self) -> RecurseIterReturn<'context, A, ((), B, C), (A, B0, C0), O>
where
&'context A: IntoIterator,
{
recurse_iter_impl!(self, 0)
}
}
impl<'context, A, A0, B: RawLock + Lockable, C, C0, O>
LockingTuple<'context, (A, B, C), (A0, B, C0), O>
{
/// Lock the second element, and return a new tuple where the first and second
/// elements are inaccessible.
#[must_use]
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn lock_1<'a>(self) -> LockReturn<'a, 'context, B, ((), (), C), (A0, B, C0), O>
where
'context: 'a,
{
lock_impl!(self, 1)
}
/// Lock the second element. The tuple becomes unusable until the returned
/// guard is dropped.
#[must_use]
pub fn lock_mut_1(&mut self) -> ContextGuard<'_, B::Guard<'_>, ThreadKey> {
lock_mut_impl!(self, 1)
}
/// Attempts to lock the second element without blocking. If successful, the
/// tuple becomes unusable until the returned guard is dropped. If the element
/// is already locked, `None` is returned.
#[must_use]
pub fn try_lock_mut_1(&mut self) -> Option<ContextGuard<'_, B::Guard<'_>, ThreadKey>> {
try_lock_mut_impl!(self, 1)
}
}
impl<'context, A, A0, B: RawLock + Sharable, C, C0, O>
LockingTuple<'context, (A, B, C), (A0, B, C0), O>
{
/// Acquire a shared lock to the second element, and return a new tuple where
/// the second element is inaccessible.
#[must_use]
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn read_1<'a>(self) -> ReadReturn<'a, 'context, B, ((), (), C), (A0, B, C0), O>
where
'context: 'a,
{
read_impl!(self, 1)
}
/// Acquire a shared lock to the second element. The tuple becomes unusable
/// until the returned guard is dropped.
#[must_use]
pub fn read_mut_1(&mut self) -> ContextGuard<'_, B::ReadGuard<'_>, ThreadKey> {
read_mut_impl!(self, 1)
}
/// Attempts to acquire a shared lock the second element without blocking. If
/// successful, the tuple becomes unusable until the returned guard is
/// dropped. If the element is already exclusively locked, `None` is returned.
#[must_use]
pub fn try_read_mut_1(&mut self) -> Option<ContextGuard<'_, B::ReadGuard<'_>, ThreadKey>> {
try_read_mut_impl!(self, 1)
}
}
impl<'context, A, A0, B, C, C0, O> LockingTuple<'context, (A, B, C), (A0, B, C0), O> {
/// Consume the tuple, and return the second element as a new tuple.
#[must_use]
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn recurse_1(self) -> RecurseReturn<'context, B, ((), (), C), (A0, B, C0), O> {
recurse_impl!(self, 1)
}
/// Consume the tuple, and return the second element as a locking iterator.
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn recurse_1_iter(self) -> RecurseIterReturn<'context, B, ((), (), C), (A0, B, C0), O>
where
&'context B: IntoIterator,
{
recurse_iter_impl!(self, 1)
}
}
impl<'context, A, A0, B, B0, C: RawLock + Lockable, O>
LockingTuple<'context, (A, B, C), (A0, B0, C), O>
{
/// Lock the third element, and return a new tuple where all elements are
/// inaccessible.
#[must_use]
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn lock_2<'a>(self) -> LockReturn<'a, 'context, C, ((), (), ()), (A0, B0, C), O>
where
'context: 'a,
{
lock_impl!(self, 2)
}
/// Lock the third element. The tuple becomes unusable until the returned
/// guard is dropped.
#[must_use]
pub fn lock_mut_2(&mut self) -> ContextGuard<'_, C::Guard<'_>, ThreadKey> {
lock_mut_impl!(self, 2)
}
/// Attempts to lock the third element without blocking. If successful, the
/// tuple becomes unusable until the returned guard is dropped. If the element
/// is already locked, `None` is returned.
#[must_use]
pub fn try_lock_mut_2(&mut self) -> Option<ContextGuard<'_, C::Guard<'_>, ThreadKey>> {
try_lock_mut_impl!(self, 2)
}
}
impl<'context, A, A0, B, B0, C: RawLock + Sharable, O>
LockingTuple<'context, (A, B, C), (A0, B0, C), O>
{
/// Acquire a shared lock to the third element, and return a new tuple where
/// the third element is inaccessible.
#[must_use]
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn read_2<'a>(self) -> ReadReturn<'a, 'context, C, ((), (), ()), (A0, B0, C), O>
where
'context: 'a,
{
read_impl!(self, 2)
}
/// Acquire a shared lock to the third element. The tuple becomes unusable
/// until the returned guard is dropped.
#[must_use]
pub fn read_mut_2(&mut self) -> ContextGuard<'_, C::ReadGuard<'_>, ThreadKey> {
read_mut_impl!(self, 2)
}
/// Attempts to acquire a shared lock the third element without blocking. If
/// successful, the tuple becomes unusable until the returned guard is
/// dropped. If the element is already exclusively locked, `None` is returned.
#[must_use]
pub fn try_read_mut_2(&mut self) -> Option<ContextGuard<'_, C::ReadGuard<'_>, ThreadKey>> {
try_read_mut_impl!(self, 2)
}
}
impl<'context, A, A0, B, B0, C, O> LockingTuple<'context, (A, B, C), (A0, B0, C), O> {
/// Consume the tuple, and return the third element as a new tuple.
#[must_use]
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn recurse_2(self) -> RecurseReturn<'context, C, ((), (), ()), (A0, B0, C), O> {
recurse_impl!(self, 2)
}
/// Consume the tuple, and return the third element as a locking iterator.
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn recurse_2_iter(self) -> RecurseIterReturn<'context, C, ((), (), ()), (A0, B0, C), O>
where
&'context C: IntoIterator,
{
recurse_iter_impl!(self, 2)
}
}
impl<'context, A, B, B0, C, C0, D, D0, O> LockingTuple<'context, (A, B, C, D), (A, B0, C0, D0), O> {
/// Consume the tuple, and return the first element as a new tuple.
#[must_use]
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn recurse_0(self) -> RecurseReturn<'context, A, ((), B, C, D), (A, B0, C0, D0), O> {
recurse_impl!(self, 0)
}
/// Consume the tuple, and return the first element as a locking iterator.
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn recurse_0_iter(self) -> RecurseIterReturn<'context, A, ((), B, C, D), (A, B0, C0, D0), O>
where
&'context A: IntoIterator,
{
recurse_iter_impl!(self, 0)
}
}
impl<'context, A, A0, B, C, C0, D, D0, O> LockingTuple<'context, (A, B, C, D), (A0, B, C0, D0), O> {
/// Consume the tuple, and return the second element as a new tuple.
#[must_use]
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn recurse_1(self) -> RecurseReturn<'context, B, ((), (), C, D), (A0, B, C0, D0), O> {
recurse_impl!(self, 1)
}
/// Consume the tuple, and return the second element as a locking iterator.
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn recurse_1_iter(
self,
) -> RecurseIterReturn<'context, B, ((), (), C, D), (A0, B, C0, D0), O>
where
&'context B: IntoIterator,
{
recurse_iter_impl!(self, 1)
}
}
impl<'context, A, A0, B, B0, C, D, D0, O> LockingTuple<'context, (A, B, C, D), (A0, B0, C, D0), O> {
/// Consume the tuple, and return the third element as a new tuple.
#[must_use]
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn recurse_2(self) -> RecurseReturn<'context, C, ((), (), (), D), (A0, B0, C, D0), O> {
recurse_impl!(self, 2)
}
/// Consume the tuple, and return the third element as a locking iterator.
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn recurse_2_iter(
self,
) -> RecurseIterReturn<'context, C, ((), (), (), D), (A0, B0, C, D0), O>
where
&'context C: IntoIterator,
{
recurse_iter_impl!(self, 2)
}
}
impl<'context, A, A0, B, B0, C, C0, D, O> LockingTuple<'context, (A, B, C, D), (A0, B0, C0, D), O> {
/// Consume the tuple, and return the fourth element as a new tuple.
#[must_use]
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn recurse_3(self) -> RecurseReturn<'context, D, ((), (), (), ()), (A0, B0, C0, D), O> {
recurse_impl!(self, 3)
}
/// Consume the tuple, and return the first element as a locking iterator.
// The type is impossible to refactor, and I already wrote this function, so no point in removing it
#[expect(clippy::type_complexity)]
pub fn recurse_3_iter(
self,
) -> RecurseIterReturn<'context, D, ((), (), (), ()), (A0, B0, C0, D), O>
where
&'context D: IntoIterator,
{
recurse_iter_impl!(self, 3)
}
}
|
