#generics #u8 #fire

unty

Explicitly types your generics

2 releases

0.0.4 Mar 7, 2025
0.0.3 Sep 24, 2023
0.0.2 Sep 23, 2023
0.0.1 Sep 23, 2023
0.0.0 Sep 23, 2023

#589 in Algorithms

Download history 199/week @ 2024-12-06 69/week @ 2024-12-13 40/week @ 2024-12-20 101/week @ 2024-12-27 243/week @ 2025-01-03 571/week @ 2025-01-10 93/week @ 2025-01-17 182/week @ 2025-01-24 92/week @ 2025-01-31 444/week @ 2025-02-07 358/week @ 2025-02-14 257/week @ 2025-02-21 7687/week @ 2025-02-28 30323/week @ 2025-03-07 31132/week @ 2025-03-14 29465/week @ 2025-03-21

98,661 downloads per month
Used in 475 crates (via bincode)

MIT/Apache

8KB

A crate that allows you to mostly-safely cast one type into another type.

This is mostly useful for generic functions, e.g.

pub fn foo<S>(s: S) {
    if let Ok(a) = unsafe { unty::<S, u8>(s) } {
        println!("It is an u8 with value {a}");
    } else {
        println!("it is not an u8");
    }
}
foo(10u8); // will print "it is an u8"
foo("test"); // will print "it is not an u8"

This operation is still unsafe because it allows you to extend lifetimes. There currently is not a way to prevent this

if let Ok(str) = unsafe { unty::<&'a str, &'static str>(input) } {
    // the compiler may now light your PC on fire
}

License

This crate is dual licenced MIT and Apache-2.0, at your own leisure


lib.rs:

A crate that allows you to untype your types.

This provides 2 functions:

type_equal allows you to check if two types are the same.

unty allows you to downcast a generic type into a concrete type.

This is mostly useful for generic functions, e.g.

pub fn foo<S>(s: S) {
    if let Ok(a) = unsafe { unty::<S, u8>(s) } {
        println!("It is an u8 with value {a}");
    } else {
        println!("it is not an u8");
    }
}
foo(10u8); // will print "it is an u8"
foo("test"); // will print "it is not an u8"

Note that both of these functions may give false positives if both types have lifetimes. There currently is not a way to prevent this. See type_equal for more information.

assert!(type_equal::<&'a str, &'static str>()); // these are not actually the same
if let Ok(str) = unsafe { unty::<&'a str, &'static str>(input) } {
    // this will extend the &'a str lifetime to be &'static, which is not allowed.
    // the compiler may now light your PC on fire.
}

No runtime deps