Struct mruby::value::Value

pub struct Value { /* fields omitted */ }

Wrapper around a sys::mrb_value.

Methods

impl Value

pub fn new(interp: &Mrb, value: mrb_value) -> Self

Construct a new Value from an interpreter and sys::mrb_value.

pub fn inner(&self) -> mrb_value

The sys::mrb_value that this Value wraps.

pub fn ruby_type(&self) -> Ruby

Return this values Rust-mapped type tag.

pub fn is_unreachable(&self) -> bool

Some type tags like MRB_TT_UNDEF are internal to the mruby VM and manipulating them with the sys API is unspecified and may result in a segfault.

After extracting a sys::mrb_value from the interpreter, check to see if the value is unreachable and propagate an MrbError::UnreachableValue error.

See: https://github.com/mruby/mruby/issues/4460

pub fn protect(&self)

Prevent this value from being garbage collected.

Calls sys::mrb_gc_protect on this value which adds it to the GC arena. This object will remain in the arena until ArenaIndex::restore restores the arena to an index before this call to protect.

pub fn is_dead(&self) -> bool

Return whether this object is unreachable by any GC roots.

pub fn to_s(&self) -> String

Call #to_s on this Value.

This function can never fail.

pub fn to_s_debug(&self) -> String

Generate a debug representation of self.

Format:

"#{self.class.name}<#{self.inspect}>"

This function can never fail.

pub fn inspect(&self) -> String

Call #inspect on this Value.

This function can never fail.

pub fn try_into<T>(self) -> Result<T, MrbError> where
    T: TryFromMrb<Self, From = Ruby, To = Rust>, 

Consume self and try to convert self to type T.

If you do not want to consume this Value, use Value::itself.

pub fn itself<T>(&self) -> Result<T, MrbError> where
    T: TryFromMrb<Self, From = Ruby, To = Rust>, 

Call #itself on this Value and try to convert the result to type T.

If you want to consume this Value, use Value::try_into.

pub fn freeze(self) -> Result<Self, MrbError>

Call #freeze on this Value and consume self.

Trait Implementations

impl FromMrb<Vec<bool>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<bool>) -> Self

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

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<Option<bool>>) -> Self

impl FromMrb<Vec<Vec<u8>>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<Vec<u8>>) -> Self

impl<'_> FromMrb<Vec<&'_ [u8]>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<&[u8]>) -> Self

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

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<Option<Vec<u8>>>) -> Self

impl<'_> FromMrb<Vec<Option<&'_ [u8]>>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<Option<&[u8]>>) -> Self

impl FromMrb<Vec<i64>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<Int>) -> Self

impl FromMrb<Vec<Option<i64>>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<Option<Int>>) -> Self

impl FromMrb<Vec<f64>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<Float>) -> Self

impl FromMrb<Vec<Option<f64>>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<Option<Float>>) -> Self

impl FromMrb<Vec<String>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<String>) -> Self

impl<'_> FromMrb<Vec<&'_ str>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<&str>) -> Self

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

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<Option<String>>) -> Self

impl<'_> FromMrb<Vec<Option<&'_ str>>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<Option<&str>>) -> Self

impl FromMrb<Vec<Value>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<Self>) -> Self

impl FromMrb<Vec<Option<Value>>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<Option<Self>>) -> Self

impl FromMrb<bool> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: bool) -> Self

impl FromMrb<Vec<u8>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<u8>) -> Self

impl<'_> FromMrb<&'_ [u8]> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: &[u8]) -> Self

impl FromMrb<i64> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Int) -> Self

impl FromMrb<u8> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: u8) -> Self

impl FromMrb<u16> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: u16) -> Self

impl FromMrb<u32> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: u32) -> Self

impl FromMrb<i8> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: i8) -> Self

impl FromMrb<i16> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: i16) -> Self

impl FromMrb<i32> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: i32) -> Self

impl FromMrb<f64> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Float) -> Self

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

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Self, Self)>) -> Self

impl FromMrb<Vec<(Option<Value>, Value)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Self>, Self)>) -> Self

impl FromMrb<Vec<(Value, Option<Value>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Self, Option<Self>)>) -> Self

impl FromMrb<Vec<(Option<Value>, Option<Value>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Self>, Option<Self>)>) -> Self

impl FromMrb<Vec<(bool, bool)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, bool)>) -> Self

impl FromMrb<HashMap<bool, bool, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, bool>) -> Self

impl FromMrb<Vec<(bool, Vec<u8>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Vec<u8>)>) -> Self

impl FromMrb<HashMap<bool, Vec<u8>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Vec<u8>>) -> Self

impl FromMrb<Vec<(bool, i64)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Int)>) -> Self

impl FromMrb<HashMap<bool, i64, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Int>) -> Self

impl FromMrb<Vec<(bool, f64)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Float)>) -> Self

impl FromMrb<HashMap<bool, f64, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Float>) -> Self

impl FromMrb<Vec<(bool, String)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, String)>) -> Self

impl FromMrb<HashMap<bool, String, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, String>) -> Self

impl FromMrb<Vec<(bool, Option<bool>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Option<bool>)>) -> Self

impl FromMrb<HashMap<bool, Option<bool>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Option<bool>>) -> Self

impl FromMrb<Vec<(bool, Option<Vec<u8>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Option<Vec<u8>>)>) -> Self

impl FromMrb<HashMap<bool, Option<Vec<u8>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Option<Vec<u8>>>) -> Self

impl FromMrb<Vec<(bool, Option<i64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Option<Int>)>) -> Self

impl FromMrb<HashMap<bool, Option<i64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Option<Int>>) -> Self

impl FromMrb<Vec<(bool, Option<f64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Option<Float>)>) -> Self

impl FromMrb<HashMap<bool, Option<f64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Option<Float>>) -> Self

impl FromMrb<Vec<(bool, Option<String>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Option<String>)>) -> Self

impl FromMrb<HashMap<bool, Option<String>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Option<String>>) -> Self

impl FromMrb<Vec<(bool, Vec<bool>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Vec<bool>)>) -> Self

impl FromMrb<HashMap<bool, Vec<bool>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Vec<bool>>) -> Self

impl FromMrb<Vec<(bool, Vec<Vec<u8>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Vec<Vec<u8>>)>) -> Self

impl FromMrb<HashMap<bool, Vec<Vec<u8>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Vec<Vec<u8>>>) -> Self

impl FromMrb<Vec<(bool, Vec<i64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Vec<Int>)>) -> Self

impl FromMrb<HashMap<bool, Vec<i64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Vec<Int>>) -> Self

impl FromMrb<Vec<(bool, Vec<f64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Vec<Float>)>) -> Self

impl FromMrb<HashMap<bool, Vec<f64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Vec<Float>>) -> Self

impl FromMrb<Vec<(bool, Vec<String>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Vec<String>)>) -> Self

impl FromMrb<HashMap<bool, Vec<String>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Vec<String>>) -> Self

impl FromMrb<Vec<(bool, Vec<Option<bool>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Vec<Option<bool>>)>) -> Self

impl FromMrb<HashMap<bool, Vec<Option<bool>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Vec<Option<bool>>>) -> Self

impl FromMrb<Vec<(bool, Vec<Option<Vec<u8>>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Vec<Option<Vec<u8>>>)>) -> Self

impl FromMrb<HashMap<bool, Vec<Option<Vec<u8>>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Vec<Option<Vec<u8>>>>) -> Self

impl FromMrb<Vec<(bool, Vec<Option<i64>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Vec<Option<Int>>)>) -> Self

impl FromMrb<HashMap<bool, Vec<Option<i64>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Vec<Option<Int>>>) -> Self

impl FromMrb<Vec<(bool, Vec<Option<f64>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Vec<Option<Float>>)>) -> Self

impl FromMrb<HashMap<bool, Vec<Option<f64>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Vec<Option<Float>>>) -> Self

impl FromMrb<Vec<(bool, Vec<Option<String>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Vec<Option<String>>)>) -> Self

impl FromMrb<HashMap<bool, Vec<Option<String>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Vec<Option<String>>>) -> Self

impl FromMrb<Vec<(Option<bool>, bool)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<bool>, bool)>) -> Self

impl FromMrb<HashMap<Option<bool>, bool, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<bool>, bool>) -> Self

impl FromMrb<Vec<(Option<bool>, Vec<u8>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<bool>, Vec<u8>)>) -> Self

impl FromMrb<HashMap<Option<bool>, Vec<u8>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<bool>, Vec<u8>>) -> Self

impl FromMrb<Vec<(Option<bool>, i64)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<bool>, Int)>) -> Self

impl FromMrb<HashMap<Option<bool>, i64, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<bool>, Int>) -> Self

impl FromMrb<Vec<(Option<bool>, f64)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<bool>, Float)>) -> Self

impl FromMrb<HashMap<Option<bool>, f64, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<bool>, Float>) -> Self

impl FromMrb<Vec<(Option<bool>, String)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<bool>, String)>) -> Self

impl FromMrb<HashMap<Option<bool>, String, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<bool>, String>) -> Self

impl FromMrb<Vec<(Option<bool>, Option<bool>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<bool>, Option<bool>)>) -> Self

impl FromMrb<HashMap<Option<bool>, Option<bool>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<bool>, Option<bool>>) -> Self

impl FromMrb<Vec<(Option<bool>, Option<Vec<u8>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<bool>, Option<Vec<u8>>)>) -> Self

impl FromMrb<HashMap<Option<bool>, Option<Vec<u8>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<bool>, Option<Vec<u8>>>) -> Self

impl FromMrb<Vec<(Option<bool>, Option<i64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<bool>, Option<Int>)>) -> Self

impl FromMrb<HashMap<Option<bool>, Option<i64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<bool>, Option<Int>>) -> Self

impl FromMrb<Vec<(Option<bool>, Option<f64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<bool>, Option<Float>)>) -> Self

impl FromMrb<HashMap<Option<bool>, Option<f64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<bool>, Option<Float>>) -> Self

impl FromMrb<Vec<(Option<bool>, Option<String>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<bool>, Option<String>)>) -> Self

impl FromMrb<HashMap<Option<bool>, Option<String>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<bool>, Option<String>>) -> Self

impl FromMrb<Vec<(Option<bool>, Vec<bool>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<bool>, Vec<bool>)>) -> Self

impl FromMrb<HashMap<Option<bool>, Vec<bool>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<bool>, Vec<bool>>) -> Self

impl FromMrb<Vec<(Option<bool>, Vec<Vec<u8>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<bool>, Vec<Vec<u8>>)>) -> Self

impl FromMrb<HashMap<Option<bool>, Vec<Vec<u8>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<bool>, Vec<Vec<u8>>>) -> Self

impl FromMrb<Vec<(Option<bool>, Vec<i64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<bool>, Vec<Int>)>) -> Self

impl FromMrb<HashMap<Option<bool>, Vec<i64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<bool>, Vec<Int>>) -> Self

impl FromMrb<Vec<(Option<bool>, Vec<f64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<bool>, Vec<Float>)>) -> Self

impl FromMrb<HashMap<Option<bool>, Vec<f64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<bool>, Vec<Float>>) -> Self

impl FromMrb<Vec<(Option<bool>, Vec<String>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<bool>, Vec<String>)>) -> Self

impl FromMrb<HashMap<Option<bool>, Vec<String>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<bool>, Vec<String>>) -> Self

impl FromMrb<Vec<(Option<bool>, Vec<Option<bool>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<bool>, Vec<Option<bool>>)>) -> Self

impl FromMrb<HashMap<Option<bool>, Vec<Option<bool>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<bool>, Vec<Option<bool>>>
) -> Self

impl FromMrb<Vec<(Option<bool>, Vec<Option<Vec<u8>>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<bool>, Vec<Option<Vec<u8>>>)>
) -> Self

impl FromMrb<HashMap<Option<bool>, Vec<Option<Vec<u8>>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<bool>, Vec<Option<Vec<u8>>>>
) -> Self

impl FromMrb<Vec<(Option<bool>, Vec<Option<i64>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<bool>, Vec<Option<Int>>)>) -> Self

impl FromMrb<HashMap<Option<bool>, Vec<Option<i64>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<bool>, Vec<Option<Int>>>
) -> Self

impl FromMrb<Vec<(Option<bool>, Vec<Option<f64>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<bool>, Vec<Option<Float>>)>
) -> Self

impl FromMrb<HashMap<Option<bool>, Vec<Option<f64>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<bool>, Vec<Option<Float>>>
) -> Self

impl FromMrb<Vec<(Option<bool>, Vec<Option<String>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<bool>, Vec<Option<String>>)>
) -> Self

impl FromMrb<HashMap<Option<bool>, Vec<Option<String>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<bool>, Vec<Option<String>>>
) -> Self

impl FromMrb<Vec<(bool, Vec<(Value, Value)>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Vec<(Value, Value)>)>) -> Self

impl FromMrb<HashMap<bool, Vec<(Value, Value)>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Vec<(Value, Value)>>) -> Self

impl FromMrb<Vec<(Option<bool>, Vec<(Value, Value)>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<bool>, Vec<(Value, Value)>)>
) -> Self

impl FromMrb<HashMap<Option<bool>, Vec<(Value, Value)>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<bool>, Vec<(Value, Value)>>
) -> Self

impl FromMrb<Vec<(bool, Value)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Value)>) -> Self

impl FromMrb<HashMap<bool, Value, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Value>) -> Self

impl FromMrb<Vec<(bool, Option<Value>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(bool, Option<Value>)>) -> Self

impl FromMrb<HashMap<bool, Option<Value>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<bool, Option<Value>>) -> Self

impl FromMrb<Vec<(Option<bool>, Value)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<bool>, Value)>) -> Self

impl FromMrb<HashMap<Option<bool>, Value, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<bool>, Value>) -> Self

impl FromMrb<Vec<(Option<bool>, Option<Value>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<bool>, Option<Value>)>) -> Self

impl FromMrb<HashMap<Option<bool>, Option<Value>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<bool>, Option<Value>>) -> Self

impl FromMrb<Vec<(Vec<u8>, bool)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, bool)>) -> Self

impl FromMrb<HashMap<Vec<u8>, bool, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, bool>) -> Self

impl FromMrb<Vec<(Vec<u8>, Vec<u8>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Vec<u8>)>) -> Self

impl FromMrb<HashMap<Vec<u8>, Vec<u8>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Vec<u8>>) -> Self

impl FromMrb<Vec<(Vec<u8>, i64)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Int)>) -> Self

impl FromMrb<HashMap<Vec<u8>, i64, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Int>) -> Self

impl FromMrb<Vec<(Vec<u8>, f64)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Float)>) -> Self

impl FromMrb<HashMap<Vec<u8>, f64, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Float>) -> Self

impl FromMrb<Vec<(Vec<u8>, String)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, String)>) -> Self

impl FromMrb<HashMap<Vec<u8>, String, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, String>) -> Self

impl FromMrb<Vec<(Vec<u8>, Option<bool>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Option<bool>)>) -> Self

impl FromMrb<HashMap<Vec<u8>, Option<bool>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Option<bool>>) -> Self

impl FromMrb<Vec<(Vec<u8>, Option<Vec<u8>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Option<Vec<u8>>)>) -> Self

impl FromMrb<HashMap<Vec<u8>, Option<Vec<u8>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Option<Vec<u8>>>) -> Self

impl FromMrb<Vec<(Vec<u8>, Option<i64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Option<Int>)>) -> Self

impl FromMrb<HashMap<Vec<u8>, Option<i64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Option<Int>>) -> Self

impl FromMrb<Vec<(Vec<u8>, Option<f64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Option<Float>)>) -> Self

impl FromMrb<HashMap<Vec<u8>, Option<f64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Option<Float>>) -> Self

impl FromMrb<Vec<(Vec<u8>, Option<String>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Option<String>)>) -> Self

impl FromMrb<HashMap<Vec<u8>, Option<String>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Option<String>>) -> Self

impl FromMrb<Vec<(Vec<u8>, Vec<bool>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Vec<bool>)>) -> Self

impl FromMrb<HashMap<Vec<u8>, Vec<bool>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Vec<bool>>) -> Self

impl FromMrb<Vec<(Vec<u8>, Vec<Vec<u8>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Vec<Vec<u8>>)>) -> Self

impl FromMrb<HashMap<Vec<u8>, Vec<Vec<u8>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Vec<Vec<u8>>>) -> Self

impl FromMrb<Vec<(Vec<u8>, Vec<i64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Vec<Int>)>) -> Self

impl FromMrb<HashMap<Vec<u8>, Vec<i64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Vec<Int>>) -> Self

impl FromMrb<Vec<(Vec<u8>, Vec<f64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Vec<Float>)>) -> Self

impl FromMrb<HashMap<Vec<u8>, Vec<f64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Vec<Float>>) -> Self

impl FromMrb<Vec<(Vec<u8>, Vec<String>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Vec<String>)>) -> Self

impl FromMrb<HashMap<Vec<u8>, Vec<String>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Vec<String>>) -> Self

impl FromMrb<Vec<(Vec<u8>, Vec<Option<bool>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Vec<Option<bool>>)>) -> Self

impl FromMrb<HashMap<Vec<u8>, Vec<Option<bool>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Vec<Option<bool>>>) -> Self

impl FromMrb<Vec<(Vec<u8>, Vec<Option<Vec<u8>>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Vec<Option<Vec<u8>>>)>) -> Self

impl FromMrb<HashMap<Vec<u8>, Vec<Option<Vec<u8>>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Vec<Option<Vec<u8>>>>) -> Self

impl FromMrb<Vec<(Vec<u8>, Vec<Option<i64>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Vec<Option<Int>>)>) -> Self

impl FromMrb<HashMap<Vec<u8>, Vec<Option<i64>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Vec<Option<Int>>>) -> Self

impl FromMrb<Vec<(Vec<u8>, Vec<Option<f64>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Vec<Option<Float>>)>) -> Self

impl FromMrb<HashMap<Vec<u8>, Vec<Option<f64>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Vec<Option<Float>>>) -> Self

impl FromMrb<Vec<(Vec<u8>, Vec<Option<String>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Vec<Option<String>>)>) -> Self

impl FromMrb<HashMap<Vec<u8>, Vec<Option<String>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Vec<Option<String>>>) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, bool)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Vec<u8>>, bool)>) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, bool, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Vec<u8>>, bool>) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, Vec<u8>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Vec<u8>>, Vec<u8>)>) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, Vec<u8>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Vec<u8>>, Vec<u8>>) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, i64)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Vec<u8>>, Int)>) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, i64, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Vec<u8>>, Int>) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, f64)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Vec<u8>>, Float)>) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, f64, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Vec<u8>>, Float>) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, String)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Vec<u8>>, String)>) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, String, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Vec<u8>>, String>) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, Option<bool>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Vec<u8>>, Option<bool>)>) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, Option<bool>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Vec<u8>>, Option<bool>>) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, Option<Vec<u8>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<Vec<u8>>, Option<Vec<u8>>)>
) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, Option<Vec<u8>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<Vec<u8>>, Option<Vec<u8>>>
) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, Option<i64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Vec<u8>>, Option<Int>)>) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, Option<i64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Vec<u8>>, Option<Int>>) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, Option<f64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Vec<u8>>, Option<Float>)>) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, Option<f64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<Vec<u8>>, Option<Float>>
) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, Option<String>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Vec<u8>>, Option<String>)>) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, Option<String>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<Vec<u8>>, Option<String>>
) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, Vec<bool>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Vec<u8>>, Vec<bool>)>) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, Vec<bool>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Vec<u8>>, Vec<bool>>) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, Vec<Vec<u8>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Vec<u8>>, Vec<Vec<u8>>)>) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, Vec<Vec<u8>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Vec<u8>>, Vec<Vec<u8>>>) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, Vec<i64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Vec<u8>>, Vec<Int>)>) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, Vec<i64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Vec<u8>>, Vec<Int>>) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, Vec<f64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Vec<u8>>, Vec<Float>)>) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, Vec<f64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Vec<u8>>, Vec<Float>>) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, Vec<String>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Vec<u8>>, Vec<String>)>) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, Vec<String>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Vec<u8>>, Vec<String>>) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, Vec<Option<bool>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<Vec<u8>>, Vec<Option<bool>>)>
) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, Vec<Option<bool>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<Vec<u8>>, Vec<Option<bool>>>
) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, Vec<Option<Vec<u8>>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<Vec<u8>>, Vec<Option<Vec<u8>>>)>
) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, Vec<Option<Vec<u8>>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<Vec<u8>>, Vec<Option<Vec<u8>>>>
) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, Vec<Option<i64>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<Vec<u8>>, Vec<Option<Int>>)>
) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, Vec<Option<i64>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<Vec<u8>>, Vec<Option<Int>>>
) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, Vec<Option<f64>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<Vec<u8>>, Vec<Option<Float>>)>
) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, Vec<Option<f64>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<Vec<u8>>, Vec<Option<Float>>>
) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, Vec<Option<String>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<Vec<u8>>, Vec<Option<String>>)>
) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, Vec<Option<String>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<Vec<u8>>, Vec<Option<String>>>
) -> Self

impl FromMrb<Vec<(Vec<u8>, Vec<(Value, Value)>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Vec<(Value, Value)>)>) -> Self

impl FromMrb<HashMap<Vec<u8>, Vec<(Value, Value)>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Vec<(Value, Value)>>) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, Vec<(Value, Value)>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<Vec<u8>>, Vec<(Value, Value)>)>
) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, Vec<(Value, Value)>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<Vec<u8>>, Vec<(Value, Value)>>
) -> Self

impl FromMrb<Vec<(Vec<u8>, Value)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Value)>) -> Self

impl FromMrb<HashMap<Vec<u8>, Value, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Value>) -> Self

impl FromMrb<Vec<(Vec<u8>, Option<Value>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Vec<u8>, Option<Value>)>) -> Self

impl FromMrb<HashMap<Vec<u8>, Option<Value>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Vec<u8>, Option<Value>>) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, Value)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Vec<u8>>, Value)>) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, Value, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Vec<u8>>, Value>) -> Self

impl FromMrb<Vec<(Option<Vec<u8>>, Option<Value>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Vec<u8>>, Option<Value>)>) -> Self

impl FromMrb<HashMap<Option<Vec<u8>>, Option<Value>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<Vec<u8>>, Option<Value>>
) -> Self

impl FromMrb<Vec<(i64, bool)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, bool)>) -> Self

impl FromMrb<HashMap<i64, bool, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, bool>) -> Self

impl FromMrb<Vec<(i64, Vec<u8>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Vec<u8>)>) -> Self

impl FromMrb<HashMap<i64, Vec<u8>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Vec<u8>>) -> Self

impl FromMrb<Vec<(i64, i64)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Int)>) -> Self

impl FromMrb<HashMap<i64, i64, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Int>) -> Self

impl FromMrb<Vec<(i64, f64)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Float)>) -> Self

impl FromMrb<HashMap<i64, f64, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Float>) -> Self

impl FromMrb<Vec<(i64, String)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, String)>) -> Self

impl FromMrb<HashMap<i64, String, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, String>) -> Self

impl FromMrb<Vec<(i64, Option<bool>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Option<bool>)>) -> Self

impl FromMrb<HashMap<i64, Option<bool>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Option<bool>>) -> Self

impl FromMrb<Vec<(i64, Option<Vec<u8>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Option<Vec<u8>>)>) -> Self

impl FromMrb<HashMap<i64, Option<Vec<u8>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Option<Vec<u8>>>) -> Self

impl FromMrb<Vec<(i64, Option<i64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Option<Int>)>) -> Self

impl FromMrb<HashMap<i64, Option<i64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Option<Int>>) -> Self

impl FromMrb<Vec<(i64, Option<f64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Option<Float>)>) -> Self

impl FromMrb<HashMap<i64, Option<f64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Option<Float>>) -> Self

impl FromMrb<Vec<(i64, Option<String>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Option<String>)>) -> Self

impl FromMrb<HashMap<i64, Option<String>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Option<String>>) -> Self

impl FromMrb<Vec<(i64, Vec<bool>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Vec<bool>)>) -> Self

impl FromMrb<HashMap<i64, Vec<bool>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Vec<bool>>) -> Self

impl FromMrb<Vec<(i64, Vec<Vec<u8>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Vec<Vec<u8>>)>) -> Self

impl FromMrb<HashMap<i64, Vec<Vec<u8>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Vec<Vec<u8>>>) -> Self

impl FromMrb<Vec<(i64, Vec<i64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Vec<Int>)>) -> Self

impl FromMrb<HashMap<i64, Vec<i64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Vec<Int>>) -> Self

impl FromMrb<Vec<(i64, Vec<f64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Vec<Float>)>) -> Self

impl FromMrb<HashMap<i64, Vec<f64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Vec<Float>>) -> Self

impl FromMrb<Vec<(i64, Vec<String>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Vec<String>)>) -> Self

impl FromMrb<HashMap<i64, Vec<String>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Vec<String>>) -> Self

impl FromMrb<Vec<(i64, Vec<Option<bool>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Vec<Option<bool>>)>) -> Self

impl FromMrb<HashMap<i64, Vec<Option<bool>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Vec<Option<bool>>>) -> Self

impl FromMrb<Vec<(i64, Vec<Option<Vec<u8>>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Vec<Option<Vec<u8>>>)>) -> Self

impl FromMrb<HashMap<i64, Vec<Option<Vec<u8>>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Vec<Option<Vec<u8>>>>) -> Self

impl FromMrb<Vec<(i64, Vec<Option<i64>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Vec<Option<Int>>)>) -> Self

impl FromMrb<HashMap<i64, Vec<Option<i64>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Vec<Option<Int>>>) -> Self

impl FromMrb<Vec<(i64, Vec<Option<f64>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Vec<Option<Float>>)>) -> Self

impl FromMrb<HashMap<i64, Vec<Option<f64>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Vec<Option<Float>>>) -> Self

impl FromMrb<Vec<(i64, Vec<Option<String>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Vec<Option<String>>)>) -> Self

impl FromMrb<HashMap<i64, Vec<Option<String>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Vec<Option<String>>>) -> Self

impl FromMrb<Vec<(Option<i64>, bool)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, bool)>) -> Self

impl FromMrb<HashMap<Option<i64>, bool, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Int>, bool>) -> Self

impl FromMrb<Vec<(Option<i64>, Vec<u8>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, Vec<u8>)>) -> Self

impl FromMrb<HashMap<Option<i64>, Vec<u8>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Int>, Vec<u8>>) -> Self

impl FromMrb<Vec<(Option<i64>, i64)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, Int)>) -> Self

impl FromMrb<HashMap<Option<i64>, i64, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Int>, Int>) -> Self

impl FromMrb<Vec<(Option<i64>, f64)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, Float)>) -> Self

impl FromMrb<HashMap<Option<i64>, f64, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Int>, Float>) -> Self

impl FromMrb<Vec<(Option<i64>, String)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, String)>) -> Self

impl FromMrb<HashMap<Option<i64>, String, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Int>, String>) -> Self

impl FromMrb<Vec<(Option<i64>, Option<bool>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, Option<bool>)>) -> Self

impl FromMrb<HashMap<Option<i64>, Option<bool>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Int>, Option<bool>>) -> Self

impl FromMrb<Vec<(Option<i64>, Option<Vec<u8>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, Option<Vec<u8>>)>) -> Self

impl FromMrb<HashMap<Option<i64>, Option<Vec<u8>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Int>, Option<Vec<u8>>>) -> Self

impl FromMrb<Vec<(Option<i64>, Option<i64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, Option<Int>)>) -> Self

impl FromMrb<HashMap<Option<i64>, Option<i64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Int>, Option<Int>>) -> Self

impl FromMrb<Vec<(Option<i64>, Option<f64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, Option<Float>)>) -> Self

impl FromMrb<HashMap<Option<i64>, Option<f64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Int>, Option<Float>>) -> Self

impl FromMrb<Vec<(Option<i64>, Option<String>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, Option<String>)>) -> Self

impl FromMrb<HashMap<Option<i64>, Option<String>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Int>, Option<String>>) -> Self

impl FromMrb<Vec<(Option<i64>, Vec<bool>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, Vec<bool>)>) -> Self

impl FromMrb<HashMap<Option<i64>, Vec<bool>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Int>, Vec<bool>>) -> Self

impl FromMrb<Vec<(Option<i64>, Vec<Vec<u8>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, Vec<Vec<u8>>)>) -> Self

impl FromMrb<HashMap<Option<i64>, Vec<Vec<u8>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Int>, Vec<Vec<u8>>>) -> Self

impl FromMrb<Vec<(Option<i64>, Vec<i64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, Vec<Int>)>) -> Self

impl FromMrb<HashMap<Option<i64>, Vec<i64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Int>, Vec<Int>>) -> Self

impl FromMrb<Vec<(Option<i64>, Vec<f64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, Vec<Float>)>) -> Self

impl FromMrb<HashMap<Option<i64>, Vec<f64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Int>, Vec<Float>>) -> Self

impl FromMrb<Vec<(Option<i64>, Vec<String>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, Vec<String>)>) -> Self

impl FromMrb<HashMap<Option<i64>, Vec<String>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Int>, Vec<String>>) -> Self

impl FromMrb<Vec<(Option<i64>, Vec<Option<bool>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, Vec<Option<bool>>)>) -> Self

impl FromMrb<HashMap<Option<i64>, Vec<Option<bool>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<Int>, Vec<Option<bool>>>
) -> Self

impl FromMrb<Vec<(Option<i64>, Vec<Option<Vec<u8>>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<Int>, Vec<Option<Vec<u8>>>)>
) -> Self

impl FromMrb<HashMap<Option<i64>, Vec<Option<Vec<u8>>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<Int>, Vec<Option<Vec<u8>>>>
) -> Self

impl FromMrb<Vec<(Option<i64>, Vec<Option<i64>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, Vec<Option<Int>>)>) -> Self

impl FromMrb<HashMap<Option<i64>, Vec<Option<i64>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Int>, Vec<Option<Int>>>) -> Self

impl FromMrb<Vec<(Option<i64>, Vec<Option<f64>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, Vec<Option<Float>>)>) -> Self

impl FromMrb<HashMap<Option<i64>, Vec<Option<f64>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<Int>, Vec<Option<Float>>>
) -> Self

impl FromMrb<Vec<(Option<i64>, Vec<Option<String>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<Int>, Vec<Option<String>>)>
) -> Self

impl FromMrb<HashMap<Option<i64>, Vec<Option<String>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<Int>, Vec<Option<String>>>
) -> Self

impl FromMrb<Vec<(i64, Vec<(Value, Value)>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Vec<(Value, Value)>)>) -> Self

impl FromMrb<HashMap<i64, Vec<(Value, Value)>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Vec<(Value, Value)>>) -> Self

impl FromMrb<Vec<(Option<i64>, Vec<(Value, Value)>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<Int>, Vec<(Value, Value)>)>
) -> Self

impl FromMrb<HashMap<Option<i64>, Vec<(Value, Value)>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<Int>, Vec<(Value, Value)>>
) -> Self

impl FromMrb<Vec<(i64, Value)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Value)>) -> Self

impl FromMrb<HashMap<i64, Value, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Value>) -> Self

impl FromMrb<Vec<(i64, Option<Value>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Int, Option<Value>)>) -> Self

impl FromMrb<HashMap<i64, Option<Value>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Int, Option<Value>>) -> Self

impl FromMrb<Vec<(Option<i64>, Value)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, Value)>) -> Self

impl FromMrb<HashMap<Option<i64>, Value, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Int>, Value>) -> Self

impl FromMrb<Vec<(Option<i64>, Option<Value>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<Int>, Option<Value>)>) -> Self

impl FromMrb<HashMap<Option<i64>, Option<Value>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<Int>, Option<Value>>) -> Self

impl FromMrb<Vec<(String, bool)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, bool)>) -> Self

impl FromMrb<HashMap<String, bool, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, bool>) -> Self

impl FromMrb<Vec<(String, Vec<u8>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Vec<u8>)>) -> Self

impl FromMrb<HashMap<String, Vec<u8>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Vec<u8>>) -> Self

impl FromMrb<Vec<(String, i64)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Int)>) -> Self

impl FromMrb<HashMap<String, i64, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Int>) -> Self

impl FromMrb<Vec<(String, f64)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Float)>) -> Self

impl FromMrb<HashMap<String, f64, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Float>) -> Self

impl FromMrb<Vec<(String, String)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, String)>) -> Self

impl FromMrb<HashMap<String, String, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, String>) -> Self

impl FromMrb<Vec<(String, Option<bool>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Option<bool>)>) -> Self

impl FromMrb<HashMap<String, Option<bool>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Option<bool>>) -> Self

impl FromMrb<Vec<(String, Option<Vec<u8>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Option<Vec<u8>>)>) -> Self

impl FromMrb<HashMap<String, Option<Vec<u8>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Option<Vec<u8>>>) -> Self

impl FromMrb<Vec<(String, Option<i64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Option<Int>)>) -> Self

impl FromMrb<HashMap<String, Option<i64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Option<Int>>) -> Self

impl FromMrb<Vec<(String, Option<f64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Option<Float>)>) -> Self

impl FromMrb<HashMap<String, Option<f64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Option<Float>>) -> Self

impl FromMrb<Vec<(String, Option<String>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Option<String>)>) -> Self

impl FromMrb<HashMap<String, Option<String>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Option<String>>) -> Self

impl FromMrb<Vec<(String, Vec<bool>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Vec<bool>)>) -> Self

impl FromMrb<HashMap<String, Vec<bool>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Vec<bool>>) -> Self

impl FromMrb<Vec<(String, Vec<Vec<u8>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Vec<Vec<u8>>)>) -> Self

impl FromMrb<HashMap<String, Vec<Vec<u8>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Vec<Vec<u8>>>) -> Self

impl FromMrb<Vec<(String, Vec<i64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Vec<Int>)>) -> Self

impl FromMrb<HashMap<String, Vec<i64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Vec<Int>>) -> Self

impl FromMrb<Vec<(String, Vec<f64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Vec<Float>)>) -> Self

impl FromMrb<HashMap<String, Vec<f64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Vec<Float>>) -> Self

impl FromMrb<Vec<(String, Vec<String>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Vec<String>)>) -> Self

impl FromMrb<HashMap<String, Vec<String>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Vec<String>>) -> Self

impl FromMrb<Vec<(String, Vec<Option<bool>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Vec<Option<bool>>)>) -> Self

impl FromMrb<HashMap<String, Vec<Option<bool>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Vec<Option<bool>>>) -> Self

impl FromMrb<Vec<(String, Vec<Option<Vec<u8>>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Vec<Option<Vec<u8>>>)>) -> Self

impl FromMrb<HashMap<String, Vec<Option<Vec<u8>>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Vec<Option<Vec<u8>>>>) -> Self

impl FromMrb<Vec<(String, Vec<Option<i64>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Vec<Option<Int>>)>) -> Self

impl FromMrb<HashMap<String, Vec<Option<i64>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Vec<Option<Int>>>) -> Self

impl FromMrb<Vec<(String, Vec<Option<f64>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Vec<Option<Float>>)>) -> Self

impl FromMrb<HashMap<String, Vec<Option<f64>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Vec<Option<Float>>>) -> Self

impl FromMrb<Vec<(String, Vec<Option<String>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Vec<Option<String>>)>) -> Self

impl FromMrb<HashMap<String, Vec<Option<String>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Vec<Option<String>>>) -> Self

impl FromMrb<Vec<(Option<String>, bool)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<String>, bool)>) -> Self

impl FromMrb<HashMap<Option<String>, bool, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<String>, bool>) -> Self

impl FromMrb<Vec<(Option<String>, Vec<u8>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<String>, Vec<u8>)>) -> Self

impl FromMrb<HashMap<Option<String>, Vec<u8>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<String>, Vec<u8>>) -> Self

impl FromMrb<Vec<(Option<String>, i64)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<String>, Int)>) -> Self

impl FromMrb<HashMap<Option<String>, i64, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<String>, Int>) -> Self

impl FromMrb<Vec<(Option<String>, f64)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<String>, Float)>) -> Self

impl FromMrb<HashMap<Option<String>, f64, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<String>, Float>) -> Self

impl FromMrb<Vec<(Option<String>, String)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<String>, String)>) -> Self

impl FromMrb<HashMap<Option<String>, String, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<String>, String>) -> Self

impl FromMrb<Vec<(Option<String>, Option<bool>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<String>, Option<bool>)>) -> Self

impl FromMrb<HashMap<Option<String>, Option<bool>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<String>, Option<bool>>) -> Self

impl FromMrb<Vec<(Option<String>, Option<Vec<u8>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<String>, Option<Vec<u8>>)>) -> Self

impl FromMrb<HashMap<Option<String>, Option<Vec<u8>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<String>, Option<Vec<u8>>>
) -> Self

impl FromMrb<Vec<(Option<String>, Option<i64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<String>, Option<Int>)>) -> Self

impl FromMrb<HashMap<Option<String>, Option<i64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<String>, Option<Int>>) -> Self

impl FromMrb<Vec<(Option<String>, Option<f64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<String>, Option<Float>)>) -> Self

impl FromMrb<HashMap<Option<String>, Option<f64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<String>, Option<Float>>) -> Self

impl FromMrb<Vec<(Option<String>, Option<String>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<String>, Option<String>)>) -> Self

impl FromMrb<HashMap<Option<String>, Option<String>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<String>, Option<String>>
) -> Self

impl FromMrb<Vec<(Option<String>, Vec<bool>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<String>, Vec<bool>)>) -> Self

impl FromMrb<HashMap<Option<String>, Vec<bool>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<String>, Vec<bool>>) -> Self

impl FromMrb<Vec<(Option<String>, Vec<Vec<u8>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<String>, Vec<Vec<u8>>)>) -> Self

impl FromMrb<HashMap<Option<String>, Vec<Vec<u8>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<String>, Vec<Vec<u8>>>) -> Self

impl FromMrb<Vec<(Option<String>, Vec<i64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<String>, Vec<Int>)>) -> Self

impl FromMrb<HashMap<Option<String>, Vec<i64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<String>, Vec<Int>>) -> Self

impl FromMrb<Vec<(Option<String>, Vec<f64>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<String>, Vec<Float>)>) -> Self

impl FromMrb<HashMap<Option<String>, Vec<f64>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<String>, Vec<Float>>) -> Self

impl FromMrb<Vec<(Option<String>, Vec<String>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<String>, Vec<String>)>) -> Self

impl FromMrb<HashMap<Option<String>, Vec<String>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<String>, Vec<String>>) -> Self

impl FromMrb<Vec<(Option<String>, Vec<Option<bool>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<String>, Vec<Option<bool>>)>
) -> Self

impl FromMrb<HashMap<Option<String>, Vec<Option<bool>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<String>, Vec<Option<bool>>>
) -> Self

impl FromMrb<Vec<(Option<String>, Vec<Option<Vec<u8>>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<String>, Vec<Option<Vec<u8>>>)>
) -> Self

impl FromMrb<HashMap<Option<String>, Vec<Option<Vec<u8>>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<String>, Vec<Option<Vec<u8>>>>
) -> Self

impl FromMrb<Vec<(Option<String>, Vec<Option<i64>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<String>, Vec<Option<Int>>)>
) -> Self

impl FromMrb<HashMap<Option<String>, Vec<Option<i64>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<String>, Vec<Option<Int>>>
) -> Self

impl FromMrb<Vec<(Option<String>, Vec<Option<f64>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<String>, Vec<Option<Float>>)>
) -> Self

impl FromMrb<HashMap<Option<String>, Vec<Option<f64>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<String>, Vec<Option<Float>>>
) -> Self

impl FromMrb<Vec<(Option<String>, Vec<Option<String>>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<String>, Vec<Option<String>>)>
) -> Self

impl FromMrb<HashMap<Option<String>, Vec<Option<String>>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<String>, Vec<Option<String>>>
) -> Self

impl FromMrb<Vec<(String, Vec<(Value, Value)>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Vec<(Value, Value)>)>) -> Self

impl FromMrb<HashMap<String, Vec<(Value, Value)>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Vec<(Value, Value)>>) -> Self

impl FromMrb<Vec<(Option<String>, Vec<(Value, Value)>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: Vec<(Option<String>, Vec<(Value, Value)>)>
) -> Self

impl FromMrb<HashMap<Option<String>, Vec<(Value, Value)>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(
    interp: &Mrb,
    value: HashMap<Option<String>, Vec<(Value, Value)>>
) -> Self

impl FromMrb<Vec<(String, Value)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Value)>) -> Self

impl FromMrb<HashMap<String, Value, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Value>) -> Self

impl FromMrb<Vec<(String, Option<Value>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(String, Option<Value>)>) -> Self

impl FromMrb<HashMap<String, Option<Value>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<String, Option<Value>>) -> Self

impl FromMrb<Vec<(Option<String>, Value)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<String>, Value)>) -> Self

impl FromMrb<HashMap<Option<String>, Value, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<String>, Value>) -> Self

impl FromMrb<Vec<(Option<String>, Option<Value>)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(Option<String>, Option<Value>)>) -> Self

impl FromMrb<HashMap<Option<String>, Option<Value>, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<Option<String>, Option<Value>>) -> Self

impl<'_> FromMrb<Vec<(&'_ str, Value)>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Vec<(&str, Value)>) -> Self

impl<'_> FromMrb<HashMap<&'_ str, Value, RandomState>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: HashMap<&str, Self>) -> Self

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

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Option<Vec<bool>>) -> Self

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

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Option<Vec<Vec<u8>>>) -> Self

impl FromMrb<Option<Vec<i64>>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Option<Vec<Int>>) -> Self

impl FromMrb<Option<Vec<f64>>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Option<Vec<Float>>) -> Self

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

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Option<Vec<String>>) -> Self

impl<'_> FromMrb<Option<Vec<&'_ str>>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Option<Vec<&str>>) -> Self

impl FromMrb<Option<bool>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Option<bool>) -> Self

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

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Option<Vec<u8>>) -> Self

impl<'_> FromMrb<Option<&'_ [u8]>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Option<&[u8]>) -> Self

impl FromMrb<Option<i64>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Option<Int>) -> Self

impl FromMrb<Option<f64>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Option<Float>) -> Self

impl FromMrb<Option<String>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Option<String>) -> Self

impl<'_> FromMrb<Option<&'_ str>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Option<&str>) -> Self

impl FromMrb<Option<Value>> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: Option<Self>) -> Self

impl FromMrb<Value> for Option<Value>

type From = Ruby

type To = Rust

fn from_mrb(_interp: &Mrb, value: Value) -> Self

impl FromMrb<String> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: String) -> Self

impl<'_> FromMrb<&'_ str> for Value

type From = Rust

type To = Ruby

fn from_mrb(interp: &Mrb, value: &str) -> Self

impl FromMrb<Value> for ()

type From = Ruby

type To = Rust

fn from_mrb(_interp: &Mrb, _value: Value) -> Self

impl FromMrb<Value> for Value

type From = Ruby

type To = Rust

fn from_mrb(_interp: &Mrb, value: Self) -> Self

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 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 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 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<(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>>

impl ValueLike for Value

fn inner(&self) -> mrb_value

fn interp(&self) -> &Mrb

fn funcall<T, M, A>(&self, func: M, args: A) -> Result<T, MrbError> where
    T: TryFromMrb<Value, From = Ruby, To = Rust>,
    M: AsRef<str>,
    A: AsRef<[Value]>, 

fn funcall_with_block<T, M, A>(
    &self,
    func: M,
    args: A,
    block: Value
) -> Result<T, MrbError> where
    T: TryFromMrb<Value, From = Ruby, To = Rust>,
    M: AsRef<str>,
    A: AsRef<[Value]>, 

fn respond_to(&self, method: &str) -> Result<bool, MrbError>

impl Clone for Value

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Display for Value

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

Formats the value using the given formatter.

impl Debug for Value

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

Formats the value using the given formatter.