[−][src]Trait mruby::convert::FromMrb

pub trait FromMrb<T> {
    type From;
    type To;
    fn from_mrb(interp: &Mrb, value: T) -> Self;
}

Associated Types

`type From`

`type To`

Loading content...

Required methods

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

Loading content...

Implementations on Foreign Types

`impl FromMrb<Value> for Option<Value>`[src]

`type From = Ruby`

`type To = Rust`

`fn from_mrb(_interp: &Mrb, value: Value) -> Self`[src]

`impl FromMrb<Value> for ()`[src]

`type From = Ruby`

`type To = Rust`

`fn from_mrb(_interp: &Mrb, _value: Value) -> Self`[src]

Loading content...

Implementors

`impl FromMrb<Option<bool>> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: Option<bool>) -> Self`[src]

`impl FromMrb<Option<f64>> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: Option<Float>) -> Self`[src]

`impl FromMrb<Option<i64>> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: Option<Int>) -> Self`[src]

`impl FromMrb<Option<Value>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Option<String>> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: Option<String>) -> Self`[src]

`impl FromMrb<Option<Vec<bool>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Option<Vec<f64>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Option<Vec<i64>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Option<Vec<u8>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Option<Vec<String>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Option<Vec<Vec<u8>>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<bool> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: bool) -> Self`[src]

`impl FromMrb<f64> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: Float) -> Self`[src]

`impl FromMrb<i16> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: i16) -> Self`[src]

`impl FromMrb<i32> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: i32) -> Self`[src]

`impl FromMrb<i64> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: Int) -> Self`[src]

`impl FromMrb<i8> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: i8) -> Self`[src]

`impl FromMrb<u16> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: u16) -> Self`[src]

`impl FromMrb<u32> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: u32) -> Self`[src]

`impl FromMrb<u8> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Value> for Value`[src]

`type From = Ruby`

`type To = Rust`

`fn from_mrb(_interp: &Mrb, value: Self) -> Self`[src]

`impl FromMrb<String> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: String) -> Self`[src]

`impl FromMrb<Vec<Option<bool>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<Option<f64>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<Option<i64>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<Option<Value>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<Option<String>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<Option<Vec<u8>>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<bool>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<f64>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<i64>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, Option<bool>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, Option<f64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, Option<i64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, Option<Value>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, Option<String>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, Option<Vec<u8>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, bool)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, f64)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, i64)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, Value)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, String)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, Vec<Option<bool>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, Vec<Option<f64>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, Vec<Option<i64>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, Vec<Option<String>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, Vec<Option<Vec<u8>>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, Vec<bool>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, Vec<f64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, Vec<i64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, Vec<(Value, Value)>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, Vec<u8>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, Vec<String>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<bool>, Vec<Vec<u8>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, bool)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, String)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, Option<bool>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, Option<String>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, Vec<bool>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, Vec<String>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, Vec<Option<bool>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, Vec<Option<String>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, Vec<(Value, Value)>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, Value)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, Option<Value>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, Option<f64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, Option<i64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, Option<Vec<u8>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, f64)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, i64)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, Vec<Option<f64>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, Vec<Option<i64>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, Vec<Option<Vec<u8>>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, Vec<f64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, Vec<i64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, Vec<u8>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<i64>, Vec<Vec<u8>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Value>, Option<Value>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Value>, Value)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, Option<bool>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, Option<f64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, Option<i64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, Option<Value>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, Option<String>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, Option<Vec<u8>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, bool)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, f64)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, i64)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, Value)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, String)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, Vec<Option<bool>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, Vec<Option<f64>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, Vec<Option<i64>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, Vec<Option<String>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, Vec<Option<Vec<u8>>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, Vec<bool>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, Vec<f64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, Vec<i64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, Vec<(Value, Value)>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, Vec<u8>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, Vec<String>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<String>, Vec<Vec<u8>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, bool)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, String)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, Option<bool>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, Option<String>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, Vec<bool>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, Vec<String>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, Vec<Option<bool>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, Vec<Option<String>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, Vec<(Value, Value)>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, Value)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, Option<Value>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, Option<f64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, Option<i64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, Option<Vec<u8>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, f64)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, i64)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, Vec<Option<f64>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, Vec<Option<i64>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, Vec<Option<Vec<u8>>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, Vec<f64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, Vec<i64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, Vec<u8>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Option<Vec<u8>>, Vec<Vec<u8>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, Option<bool>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, Option<f64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, Option<i64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, Option<Value>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, Option<String>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, Option<Vec<u8>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, bool)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, f64)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, i64)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, Value)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, String)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, Vec<Option<bool>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, Vec<Option<f64>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, Vec<Option<i64>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, Vec<Option<String>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, Vec<Option<Vec<u8>>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, Vec<bool>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, Vec<f64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, Vec<i64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, Vec<(Value, Value)>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, Vec<u8>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, Vec<String>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(bool, Vec<Vec<u8>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, bool)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, String)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, Option<bool>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, Option<String>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, Vec<bool>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, Vec<String>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, Vec<Option<bool>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, Vec<Option<String>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, Vec<(Value, Value)>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, Value)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, Option<Value>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, Option<f64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, Option<i64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, Option<Vec<u8>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, f64)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, i64)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, Vec<Option<f64>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, Vec<Option<i64>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, Vec<Option<Vec<u8>>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, Vec<f64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, Vec<i64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, Vec<u8>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(i64, Vec<Vec<u8>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Value, Option<Value>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Value, Value)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, Option<bool>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, Option<f64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, Option<i64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, Option<Value>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, Option<String>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, Option<Vec<u8>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, bool)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, f64)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, i64)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, Value)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, String)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, Vec<Option<bool>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, Vec<Option<f64>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, Vec<Option<i64>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, Vec<Option<String>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, Vec<Option<Vec<u8>>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, Vec<bool>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, Vec<f64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, Vec<i64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, Vec<(Value, Value)>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, Vec<u8>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, Vec<String>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(String, Vec<Vec<u8>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, bool)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, String)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, Option<bool>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, Option<String>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, Vec<bool>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, Vec<String>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, Vec<Option<bool>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, Vec<Option<String>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, Vec<(Value, Value)>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, Value)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, Option<Value>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, Option<f64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, Option<i64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, Option<Vec<u8>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, f64)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, i64)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, Vec<Option<f64>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, Vec<Option<i64>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, Vec<Option<Vec<u8>>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, Vec<f64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, Vec<i64>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, Vec<u8>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<(Vec<u8>, Vec<Vec<u8>>)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<u8>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<Value>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<String>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Vec<Vec<u8>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, Option<bool>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, Option<f64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, Option<i64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, Option<Value>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, Option<String>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, Option<Vec<u8>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, bool, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, f64, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, i64, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, Value, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, String, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, Vec<Option<bool>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, Vec<Option<f64>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, Vec<Option<i64>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, Vec<Option<String>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, Vec<Option<Vec<u8>>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, Vec<bool>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, Vec<f64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, Vec<i64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, Vec<(Value, Value)>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, Vec<u8>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, Vec<String>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<bool>, Vec<Vec<u8>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, bool, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, String, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, Option<bool>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, Option<String>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, Vec<bool>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, Vec<String>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, Vec<Option<bool>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, Vec<Option<String>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, Vec<(Value, Value)>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, Value, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, Option<Value>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, Option<f64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, Option<i64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, Option<Vec<u8>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, f64, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, i64, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, Vec<Option<f64>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, Vec<Option<i64>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, Vec<Option<Vec<u8>>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, Vec<f64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, Vec<i64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, Vec<u8>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<i64>, Vec<Vec<u8>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, Option<bool>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, Option<f64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, Option<i64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, Option<Value>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, Option<String>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, Option<Vec<u8>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, bool, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, f64, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, i64, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, Value, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, String, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, Vec<Option<bool>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, Vec<Option<f64>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, Vec<Option<i64>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, Vec<Option<String>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, Vec<Option<Vec<u8>>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, Vec<bool>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, Vec<f64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, Vec<i64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, Vec<(Value, Value)>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, Vec<u8>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, Vec<String>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<String>, Vec<Vec<u8>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, bool, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, String, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, Option<bool>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, Option<String>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, Vec<bool>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, Vec<String>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, Vec<Option<bool>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, Vec<Option<String>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, Vec<(Value, Value)>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, Value, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, Option<Value>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, Option<f64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, Option<i64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, Option<Vec<u8>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, f64, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, i64, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, Vec<Option<f64>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, Vec<Option<i64>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, Vec<Option<Vec<u8>>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, Vec<f64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, Vec<i64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, Vec<u8>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Option<Vec<u8>>, Vec<Vec<u8>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, Option<bool>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, Option<f64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, Option<i64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, Option<Value>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, Option<String>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, Option<Vec<u8>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, bool, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, f64, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, i64, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, Value, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, String, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, Vec<Option<bool>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, Vec<Option<f64>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, Vec<Option<i64>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, Vec<Option<String>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, Vec<Option<Vec<u8>>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, Vec<bool>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, Vec<f64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, Vec<i64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, Vec<(Value, Value)>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, Vec<u8>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, Vec<String>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<bool, Vec<Vec<u8>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, bool, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, String, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, Option<bool>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, Option<String>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, Vec<bool>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, Vec<String>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, Vec<Option<bool>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, Vec<Option<String>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, Vec<(Value, Value)>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, Value, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, Option<Value>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, Option<f64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, Option<i64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, Option<Vec<u8>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, f64, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, i64, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, Vec<Option<f64>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, Vec<Option<i64>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, Vec<Option<Vec<u8>>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, Vec<f64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, Vec<i64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, Vec<u8>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<i64, Vec<Vec<u8>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, Option<bool>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, Option<f64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, Option<i64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, Option<Value>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, Option<String>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, Option<Vec<u8>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, bool, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, f64, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, i64, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, Value, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, String, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, Vec<Option<bool>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, Vec<Option<f64>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, Vec<Option<i64>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, Vec<Option<String>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, Vec<Option<Vec<u8>>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, Vec<bool>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, Vec<f64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, Vec<i64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, Vec<(Value, Value)>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, Vec<u8>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, Vec<String>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<String, Vec<Vec<u8>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, bool, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, String, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, Option<bool>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, Option<String>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, Vec<bool>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, Vec<String>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, Vec<Option<bool>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, Vec<Option<String>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, Vec<(Value, Value)>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, Value, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, Option<Value>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, Option<f64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, Option<i64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, Option<Vec<u8>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, f64, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, i64, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, Vec<Option<f64>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, Vec<Option<i64>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, Vec<Option<Vec<u8>>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, Vec<f64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, Vec<i64>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, Vec<u8>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<HashMap<Vec<u8>, Vec<Vec<u8>>, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl<'_> FromMrb<&'_ str> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: &str) -> Self`[src]

`impl<'_> FromMrb<Option<&'_ str>> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: Option<&str>) -> Self`[src]

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

`type From = Rust`

`type To = Ruby`

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

`impl<'_> FromMrb<Option<Vec<&'_ str>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

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

`type From = Rust`

`type To = Ruby`

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

`impl<'_> FromMrb<Vec<&'_ str>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl<'_> FromMrb<Vec<Option<&'_ str>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

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

`type From = Rust`

`type To = Ruby`

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

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

`type From = Rust`

`type To = Ruby`

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

`impl<'_> FromMrb<Vec<(&'_ str, Value)>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl<'_> FromMrb<HashMap<&'_ str, Value, RandomState>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

Loading content...

[−][src]Trait mruby::convert::FromMrb

Associated Types

type From

type To

Required methods

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

Implementations on Foreign Types

impl FromMrb<Value> for Option<Value>[src]

type From = Ruby

type To = Rust

fn from_mrb(_interp: &Mrb, value: Value) -> Self[src]

impl FromMrb<Value> for ()[src]

type From = Ruby

type To = Rust

fn from_mrb(_interp: &Mrb, _value: Value) -> Self[src]

Implementors

impl FromMrb<Option<bool>> for Value[src]

type From = Rust

type To = Ruby

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

impl FromMrb<Option<f64>> for Value[src]

type From = Rust

type To = Ruby

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

impl FromMrb<Option<i64>> for Value[src]

type From = Rust

type To = Ruby

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

impl FromMrb<Option<Value>> for Value[src]

type From = Rust

type To = Ruby

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

impl FromMrb<Option<String>> for Value[src]

type From = Rust

type To = Ruby

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

impl FromMrb<Option<Vec<bool>>> for Value[src]

type From = Rust

type To = Ruby

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

impl FromMrb<Option<Vec<f64>>> for Value[src]

type From = Rust

type To = Ruby

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

impl FromMrb<Option<Vec<i64>>> for Value[src]

type From = Rust

type To = Ruby

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

impl FromMrb<Option<Vec<u8>>> for Value[src]

type From = Rust

type To = Ruby

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

impl FromMrb<Option<Vec<String>>> for Value[src]

type From = Rust

type To = Ruby

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

impl FromMrb<Option<Vec<Vec<u8>>>> for Value[src]

type From = Rust

type To = Ruby

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

impl FromMrb<bool> for Value[src]

type From = Rust

type To = Ruby

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

impl FromMrb<f64> for Value[src]

type From = Rust

type To = Ruby

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

impl FromMrb<i16> for Value[src]

type From = Rust

type To = Ruby

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

impl FromMrb<i32> for Value[src]

type From = Rust

type To = Ruby

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

impl FromMrb<i64> for Value[src]

type From = Rust

type To = Ruby

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

`type From`

`type To`

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

`impl FromMrb<Value> for Option<Value>`[src]

`type From = Ruby`

`type To = Rust`

`fn from_mrb(_interp: &Mrb, value: Value) -> Self`[src]

`impl FromMrb<Value> for ()`[src]

`type From = Ruby`

`type To = Rust`

`fn from_mrb(_interp: &Mrb, _value: Value) -> Self`[src]

`impl FromMrb<Option<bool>> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: Option<bool>) -> Self`[src]

`impl FromMrb<Option<f64>> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: Option<Float>) -> Self`[src]

`impl FromMrb<Option<i64>> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: Option<Int>) -> Self`[src]

`impl FromMrb<Option<Value>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Option<String>> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: Option<String>) -> Self`[src]

`impl FromMrb<Option<Vec<bool>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Option<Vec<f64>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Option<Vec<i64>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Option<Vec<u8>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Option<Vec<String>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<Option<Vec<Vec<u8>>>> for Value`[src]

`type From = Rust`

`type To = Ruby`

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

`impl FromMrb<bool> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: bool) -> Self`[src]

`impl FromMrb<f64> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: Float) -> Self`[src]

`impl FromMrb<i16> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: i16) -> Self`[src]

`impl FromMrb<i32> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: i32) -> Self`[src]

`impl FromMrb<i64> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: Int) -> Self`[src]

`impl FromMrb<i8> for Value`[src]

`type From = Rust`

`type To = Ruby`

`fn from_mrb(interp: &Mrb, value: i8) -> Self`[src]

`impl FromMrb<u16> for Value`[src]