Idea: trait FromInner & ToInner and derive for one field tuple struct

trait FromInner<T> {
    fn from_inner(inner: T) -> Self;

trait ToInner<T> {
    fn to_inner(self) -> T;

#[derive(FromInner, ToInner)]
struct Wrapper(u32);

// derived impl

impl FromInner<u32> for Wrapper {
    fn from_inner(inner: u32) -> Self {

impl ToInner<u32> for Wrapper {
    fn to_inner(self) -> u32 {

The reason for this is that I want to implement a trait for checking and initializing like this:

struct CheckError;

trait Check<T>: Sized + FromInner<T> {
    fn check(inner: &T) -> Result<(), CheckError>;

    fn from_checked(inner: T) -> Result<Self, CheckError> {

For that use case the From<T> trait should be enough. Are you thinking on some additional meaning?

Check's definition doesn't sound right. To implement a checked fallible conversion (the Check trait) you also need to implement an infallible one (the FromInner trait)?