scope-lock 0.3.1

Safely extend lifetimes
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

//! `'static` versions of the most popular functions.
//!
//! This module contains a way to type erase popular functions for any requested type without using
//! dynamic dispatch. It overcomes limitaions of generic free functions' instances inheriting
//! lifetime from a generic arguments.
//!
use core::{
    future::Future,
    panic::{RefUnwindSafe, UnwindSafe},
    pin::Pin,
    task,
};

use super::{PointerDeref, PointerDerefMut, PointerIntoInner, PointerLike, PointerPinUnforgotten};

/// Get `'static` function of drop on a `P` pointer type.
///
/// # Safety
///
/// Only valid pointers of the same original smart-pointer type `P` must be passed to the returned
/// closure otherwise causing undefined behaviour.
pub const unsafe fn fn_drop<P: PointerLike>(
) -> impl Fn(*mut ()) + Copy + Send + Sync + UnwindSafe + RefUnwindSafe + Unpin + 'static {
    |erased_ptr| drop(unsafe { P::from_ptr(erased_ptr as *mut P::Pointee) })
}

pub const unsafe fn fn_call<P, I, O>(
) -> impl Fn(*const (), I) -> O + Copy + Send + Sync + UnwindSafe + RefUnwindSafe + Unpin + 'static
where
    P: PointerDeref,
    P::Pointee: Fn(I) -> O,
{
    |erased_ptr, input| unsafe { (*(erased_ptr as *const P::Pointee))(input) }
}

pub const unsafe fn fn_call_mut<P, I, O>(
) -> impl Fn(*mut (), I) -> O + Copy + Send + Sync + UnwindSafe + RefUnwindSafe + Unpin + 'static
where
    P: PointerDerefMut,
    P::Pointee: FnMut(I) -> O,
{
    |erased_ptr, input| unsafe { (*(erased_ptr as *mut P::Pointee))(input) }
}

pub const unsafe fn fn_call_once<P, I, O>(
) -> impl Fn(*mut (), I) -> O + Copy + Send + Sync + UnwindSafe + RefUnwindSafe + Unpin + 'static
where
    P: PointerIntoInner,
    P::Pointee: FnOnce(I) -> O,
{
    |erased_ptr, input| (unsafe { P::from_ptr(erased_ptr as *mut P::Pointee) }).into_inner()(input)
}

pub const unsafe fn fn_poll_unforgotten<P, O>(
) -> impl Fn(*mut (), &mut task::Context<'_>) -> task::Poll<O>
       + Copy
       + Send
       + Sync
       + UnwindSafe
       + RefUnwindSafe
       + Unpin
       + 'static
where
    P: PointerPinUnforgotten,
    P::Pointee: Future<Output = O>,
{
    |erased_ptr, cx| unsafe { (Pin::new_unchecked(&mut *(erased_ptr as *mut P::Pointee))).poll(cx) }
}