Trait mruby::convert::TryFromMrb

pub trait TryFromMrb<T> where
    Self: Sized, {
    type From;
    type To;
    unsafe fn try_from_mrb(
        interp: &Mrb, 
        value: T
    ) -> Result<Self, Error<Self::From, Self::To>>;
}

Associated Types

type From

type To

Loading content...

Required methods

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: T
) -> Result<Self, Error<Self::From, Self::To>>

Loading content...

Implementations on Foreign Types

impl TryFromMrb<Value> for Vec<bool>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Vec<Option<bool>>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Vec<Vec<u8>>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Vec<Option<Vec<u8>>>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Vec<Int>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Vec<Option<Int>>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Vec<Float>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Vec<Option<Float>>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Vec<String>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Vec<Option<String>>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Vec<Value>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Vec<Option<Value>>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for bool

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    _interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Vec<u8>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for usize

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Vec<(Value, Value)>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, bool, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Vec<u8>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Int, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Float, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, String, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Option<bool>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Option<Vec<u8>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Option<Int>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Option<Float>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Option<String>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Vec<bool>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Vec<Vec<u8>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Vec<Int>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Vec<Float>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Vec<String>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Vec<Option<bool>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Vec<Option<Vec<u8>>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Vec<Option<Int>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Vec<Option<Float>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Vec<Option<String>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, bool, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Vec<u8>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Int, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Float, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, String, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Option<bool>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Option<Vec<u8>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Option<Int>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Option<Float>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Option<String>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Vec<bool>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Vec<Vec<u8>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Vec<Int>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Vec<Float>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Vec<String>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Vec<Option<bool>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Vec<Option<Vec<u8>>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Vec<Option<Int>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Vec<Option<Float>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Vec<Option<String>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Vec<(Value, Value)>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Vec<(Value, Value)>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Value, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<bool, Option<Value>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Value, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<bool>, Option<Value>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, bool, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Vec<u8>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Int, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Float, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, String, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Option<bool>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Option<Vec<u8>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Option<Int>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Option<Float>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Option<String>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Vec<bool>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Vec<Vec<u8>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Vec<Int>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Vec<Float>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Vec<String>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Vec<Option<bool>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Vec<Option<Vec<u8>>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Vec<Option<Int>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Vec<Option<Float>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Vec<Option<String>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, bool, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Vec<u8>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Int, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Float, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, String, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Option<bool>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Option<Vec<u8>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Option<Int>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Option<Float>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Option<String>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Vec<bool>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Vec<Vec<u8>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Vec<Int>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Vec<Float>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Vec<String>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Vec<Option<bool>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Vec<Option<Vec<u8>>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Vec<Option<Int>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Vec<Option<Float>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Vec<Option<String>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Vec<(Value, Value)>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Vec<(Value, Value)>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Value, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Vec<u8>, Option<Value>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Value, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Vec<u8>>, Option<Value>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, bool, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Vec<u8>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Int, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Float, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, String, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Option<bool>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Option<Vec<u8>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Option<Int>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Option<Float>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Option<String>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Vec<bool>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Vec<Vec<u8>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Vec<Int>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Vec<Float>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Vec<String>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Vec<Option<bool>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Vec<Option<Vec<u8>>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Vec<Option<Int>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Vec<Option<Float>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Vec<Option<String>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, bool, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Vec<u8>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Int, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Float, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, String, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Option<bool>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Option<Vec<u8>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Option<Int>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Option<Float>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Option<String>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Vec<bool>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Vec<Vec<u8>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Vec<Int>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Vec<Float>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Vec<String>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Vec<Option<bool>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Vec<Option<Vec<u8>>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Vec<Option<Int>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Vec<Option<Float>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Vec<Option<String>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Vec<(Value, Value)>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Vec<(Value, Value)>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Value, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Int, Option<Value>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Value, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<Int>, Option<Value>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, bool, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Vec<u8>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Int, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Float, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, String, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Option<bool>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Option<Vec<u8>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Option<Int>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Option<Float>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Option<String>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Vec<bool>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Vec<Vec<u8>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Vec<Int>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Vec<Float>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Vec<String>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Vec<Option<bool>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Vec<Option<Vec<u8>>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Vec<Option<Int>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Vec<Option<Float>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Vec<Option<String>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, bool, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Vec<u8>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Int, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Float, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, String, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Option<bool>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Option<Vec<u8>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Option<Int>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Option<Float>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Option<String>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Vec<bool>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Vec<Vec<u8>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Vec<Int>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Vec<Float>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Vec<String>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Vec<Option<bool>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Vec<Option<Vec<u8>>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Vec<Option<Int>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Vec<Option<Float>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Vec<Option<String>>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Vec<(Value, Value)>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Vec<(Value, Value)>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Value, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<String, Option<Value>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Value, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<S: BuildHasher + Default> TryFromMrb<Value> for HashMap<Option<String>, Option<Value>, S>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Option<Vec<bool>>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Option<Vec<Vec<u8>>>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Option<Vec<Int>>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Option<Vec<Float>>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Option<Vec<String>>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Option<bool>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Option<Vec<u8>>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Option<Int>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Option<Float>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Option<String>

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for String

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

Loading content...

Implementors

impl TryFromMrb<Value> for Float

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    _interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl TryFromMrb<Value> for Int

type From = Ruby

type To = Rust

unsafe fn try_from_mrb(
    _interp: &Mrb,
    value: Value
) -> Result<Self, Error<Self::From, Self::To>>

impl<From, To> TryFromMrb<From> for To where
    To: FromMrb<From>, 

Provide a falible converter for types that implement an infallible conversion.

type From = Self::From

type To = Self::To

unsafe fn try_from_mrb(
    interp: &Mrb,
    value: From
) -> Result<Self, Error<Self::From, Self::To>>

Loading content...