[go: up one dir, main page]

unsize 1.1.0

A stable alternative to CoerceUnsize
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
69
70
71

use unsize::{Coercion, CoerceUnsize};

#[test]
fn any() {
    use core::any::Any;
    fn generic<T: Any>(ptr: &T) -> &dyn Any {
        ptr.unsize(Coercion::to_any())
    }
    generic(&0u32);
    fn generic_mut<T: Any>(ptr: &mut T) -> &mut dyn Any {
        ptr.unsize(Coercion::to_any())
    }
    generic_mut(&mut 0u32);
    use core::pin::Pin;
    fn generic_mut_pinned<T: Any>(ptr: Pin<&mut T>) -> Pin<&mut dyn Any> {
        ptr.unsize(Coercion::to_any())
    }
    let mut p = (0_u32, ::core::marker::PhantomPinned);
    let p = unsafe {
        Pin::new_unchecked(&mut p)
    };
    generic_mut_pinned(p);
}

#[test]
fn debug() {
    use core::fmt::Debug;
    fn generic<T: Debug>(ptr: &T) -> &dyn Debug {
        ptr.unsize(Coercion::to_debug())
    }
    generic(&0u32);
}

#[test]
fn display() {
    use core::fmt::Display;
    fn generic<T: Display>(ptr: &T) -> &dyn Display {
        ptr.unsize(Coercion::to_display())
    }
    generic(&0u32);
}

#[cfg(rustc_1_51)]
#[test]
fn to_slice() {
    fn generic<T>(ptr: &[T; 4]) -> &[T] {
        ptr.unsize(Coercion::to_slice())
    }
    generic(&[0u32; 4]);
}

#[test]
fn functions() {
    fn arg0<F: 'static + FnOnce()>(fptr: &F) -> &dyn FnOnce() {
        fptr.unsize(Coercion::<_, dyn FnOnce()>::to_fn_once())
    }

    fn arg1<F: 'static + FnOnce(u32)>(fptr: &F) -> &dyn FnOnce(u32) {
        fptr.unsize(Coercion::<_, dyn FnOnce(u32)>::to_fn_once())
    }

    fn arg6<F: 'static + FnOnce(u32,u32,u32,u32,u32,u32)>(fptr: &F)
        -> &dyn FnOnce(u32,u32,u32,u32,u32,u32)
    {
        fptr.unsize(Coercion::<_, dyn FnOnce(u32,u32,u32,u32,u32,u32)>::to_fn_once())
    }

    arg0(&|| {});
    arg1(&|_| {});
    arg6(&|_,_,_,_,_,_| {});
}