Struct unsize::Coercion

#[repr(C)]pub struct Coercion<T, U: ?Sized, F: FnOnce(*const T) -> *const U = fn(_: *const T) -> *const U> { /* fields omitted */ }

Enables the unsizing of a sized pointer.

Implementations

impl<F, T, U: ?Sized> Coercion<T, U, F> where
    F: FnOnce(*const T) -> *const U, 

pub unsafe fn new(coerce: F) -> Self

Construct a new coercer.

Safety

The method must not perform any action other than unsizing the pointer.

Usage

use unsize::Coercion;
use core::fmt::Debug;

let c: Coercion<u32, dyn Debug> = unsafe {
    Coercion::new(|x| x)
};

impl<'lt, T: Any + 'lt> Coercion<T, dyn Any + 'lt>

pub fn to_any() -> Self

Create a coercer that unsizes and keeps dynamic type information.

Usage

use unsize::{Coercion, CoerceUnsize};
use core::any::Any;

fn generic<T: Any>(ptr: &T) -> &dyn Any {
    ptr.unsize(Coercion::to_any())
}

impl<'lt, T: Debug + 'lt> Coercion<T, dyn Debug + 'lt>

pub fn to_debug() -> Self

Create a coercer that unsizes a parameter to dynamically debug its fields.

Usage

use unsize::{Coercion, CoerceUnsize};
use core::fmt::Debug;

fn generic<T: Debug>(ptr: &T) -> &dyn Debug {
    ptr.unsize(Coercion::to_debug())
}

impl<'lt, T: Display + 'lt> Coercion<T, dyn Display + 'lt>

pub fn to_display() -> Self

Create a coercer that unsizes a parameter to display it.

Usage

use unsize::{Coercion, CoerceUnsize};
use core::fmt::Display;

fn generic<T: Display>(ptr: &T) -> &dyn Display {
    ptr.unsize(Coercion::to_display())
}

impl<T, const N: usize> Coercion<[T; N], [T]>

pub fn to_slice() -> Self

Create a coercer that unsizes an array to a slice.

Usage

use unsize::{Coercion, CoerceUnsize};
use core::fmt::Display;

fn generic<T>(ptr: &[T; 2]) -> &[T] {
    ptr.unsize(Coercion::to_slice())
}

impl<'lt, T: Fn(A, B, C, D, E, G) -> Ret + 'lt, Ret, A, B, C, D, E, G> Coercion<T, dyn Fn(A, B, C, D, E, G) -> Ret + 'lt>

pub fn to_fn() -> Self

Create a coercer that unsizes to a dynamically dispatched function.

This is implemented for function arities up to the shown one (other methods / impls are hidden in the docs for readability)

impl<'lt, T: FnMut(A, B, C, D, E, G) -> Ret + 'lt, Ret, A, B, C, D, E, G> Coercion<T, dyn FnMut(A, B, C, D, E, G) -> Ret + 'lt>

pub fn to_fn_mut() -> Self

Create a coercer that unsizes to a dynamically dispatched mutable function.

This is implemented for function arities up to the shown one (other methods / impls are hidden in the docs for readability)

impl<'lt, T: FnOnce(A, B, C, D, E, G) -> Ret + 'lt, Ret, A, B, C, D, E, G> Coercion<T, dyn FnOnce(A, B, C, D, E, G) -> Ret + 'lt>

pub fn to_fn_once() -> Self

Create a coercer that unsizes to a dynamically dispatched once function.

This is implemented for function arities up to the shown one (other methods / impls are hidden in the docs for readability)

impl<'lt, T: Iterator<Item = I> + 'lt, I> Coercion<T, dyn Iterator<Item = I> + 'lt>

pub fn to_iterator() -> Self

Create a coercer that unsizes to a dynamically dispatched iterator.

This is implemented for all iterator types. It can type-erase the concrete type to wrap an otherwise unnameable adapter in a custom smart pointer, to store it within a struct.

Usage

// A non-coercible box, for demonstration purposes
struct MyBox<T: ?Sized>(Box<T>);

unsafe impl<'lt, T, U: ?Sized + 'lt> CoerciblePtr<U> for MyBox<T> {
    // …
}

use unsize::{Coercion, CoerceUnsize};
use core::fmt::Display;

fn maybe_empty<T: Clone>(item: &T) -> MyBox<dyn Iterator<Item=T> + '_> {
    if core::mem::size_of::<T>() % 2 == 0 {
        MyBox::new(core::iter::empty())
            .unsize(Coercion::to_iterator())
    } else {
        MyBox::new(core::iter::repeat(item.clone()))
            .unsize(Coercion::to_iterator())
    }
}

impl<'lt, T: Future<Output = I> + 'lt, I> Coercion<T, dyn Future<Output = I> + 'lt>

pub fn to_future() -> Self

Create a coercer that unsizes to a dynamically dispatched future.

This is implemented for all iterator types. It can type-erase the concrete type to wrap an otherwise unnameable adapter in a custom smart pointer, to store it within a struct.

Usage

// A non-coercible box, for demonstration purposes
struct MyBox<T: ?Sized>(Box<T>);

unsafe impl<'lt, T, U: ?Sized + 'lt> CoerciblePtr<U> for MyBox<T> {
    // …
}

use unsize::{Coercion, CoerceUnsize};
use core::fmt::Display;

fn maybe_empty<T: 'static>(val: T) -> MyBox<dyn Future<Output=T>> {
    if core::mem::size_of::<T>() % 2 == 0 {
        MyBox::new(core::future::pending())
            .unsize(Coercion::to_future())
    } else {
        MyBox::new(core::future::ready(val))
            .unsize(Coercion::to_future())
    }
}

Trait Implementations

impl<T, U: ?Sized, F: FnOnce(*const T) -> *const U> Clone for Coercion<T, U, F> where
    F: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, U: ?Sized, F: FnOnce(*const T) -> *const U> Copy for Coercion<T, U, F> where
    F: Copy, 

impl<T, U: ?Sized, F: FnOnce(*const T) -> *const U> Debug for Coercion<T, U, F> where
    F: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, U: ?Sized, F: FnOnce(*const T) -> *const U> Eq for Coercion<T, U, F> where
    F: Eq, 

impl<T, U: ?Sized, F: FnOnce(*const T) -> *const U> Hash for Coercion<T, U, F> where
    F: Hash, 

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<T, U: ?Sized, F: FnOnce(*const T) -> *const U> PartialEq<Coercion<T, U, F>> for Coercion<T, U, F> where
    F: PartialEq, 

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.