Struct huff_coding::tree::HuffTree [−][src]
Struct representing a Huffman Tree with an alphabet of
type implementing HuffLetter
A HuffTree
can be initialized in two ways:
- from a struct implementing the
Weights<L>
trait (from_weights
), whereL
must implement theHuffLetter
trait - from a binary representation (
try_from_bin
):BitVec<Msb0, u8>
, where in order to even get it,L
must implement theHuffLetterAsBytes
trait
Codes stored by the tree can be retrieved using the codes
method
How it works
When initialized with the HuffTree::from_weights
method it
follows the steps of the Huffman Coding algorithm (duh):
- Creates standalone branches for every letter found in the given weights and pushes them onto a branch heap
- Finds two branches with the lowest weights
- Makes them children to a branch with a
None
letter and the children’s summed up weight - Removes the two found branches from the heap and adds the newly created branch into it
- Repeats steps 2 to 4 until there’s only one branch left
- Sets the only branch left as root
- Recurses into the tree to set every branch’s code
- Every branch gets its parent’s code with its own position in the parent branch (left - 0, right - 1)
Initializing from bits goes as follows:
- Go through the
HuffTree
encoded in binary (big endian) bit by bit - Every 1 means a joint branch
- Every 0 means a letter branch followed by
size_of::<L> * 8
bits representing the stored letter
Examples
Initialization from ByteWeights
use huff_coding::{ bitvec::prelude::*, prelude::{HuffTree, ByteWeights}, }; use std::collections::HashMap; let tree = HuffTree::from_weights( ByteWeights::from_bytes(b"abbccc") ); let codes = tree.read_codes(); assert_eq!( codes.get(&b'c').unwrap(), &bitvec![Msb0, u8; 0] ); assert_eq!( codes.get(&b'b').unwrap(), &bitvec![Msb0, u8; 1, 1] ); assert_eq!( codes.get(&b'a').unwrap(), &bitvec![Msb0, u8; 1, 0] );
Initialization from HashMap<L, usize>
:
use huff_coding::{ bitvec::prelude::*, prelude::{HuffTree, Weights}, }; use std::collections::HashMap; let mut weights = HashMap::new(); weights.insert(String::from("pudzian"), 1); weights.insert(String::from("krol"), 2); weights.insert(String::from("szef"), 3); let tree = HuffTree::from_weights(weights); let codes = tree.read_codes(); assert_eq!( codes.get("szef").unwrap(), &bitvec![Msb0, u8; 0] ); assert_eq!( codes.get("krol").unwrap(), &bitvec![Msb0, u8; 1, 1] ); assert_eq!( codes.get("pudzian").unwrap(), &bitvec![Msb0, u8; 1, 0] );
Representing and reading the tree from bits:
use huff_coding::prelude::{HuffTree, ByteWeights}; let tree = HuffTree::from_weights( ByteWeights::from_bytes(b"abbccc") ); let tree_bin = tree.as_bin(); // the tree's root's left child is a letter branch, which are encoded by a 0 assert_eq!(*tree_bin.get(1).unwrap(), false); let new_tree = HuffTree::try_from_bin(tree_bin).unwrap(); // the newly created tree is identical, except in weights assert_eq!( tree.read_codes(), new_tree.read_codes() ); assert_ne!( tree .root() .leaf() .weight(), new_tree .root() .leaf() .weight() ); // every weight in a HuffTree read from binary is set to 0 assert_eq!( new_tree .root() .leaf() .weight(), 0 );
Panics
When trying to create a HuffTree<L>
from a type implementing
Weights<L>
with len == 0:
use huff_coding::prelude::{HuffTree, Weights}; use std::collections::HashMap; let weights = HashMap::<char, usize>::new(); // panics here at 'provided empty weights' let tree = HuffTree::from_weights(weights);
Errors
When trying to create a HuffTree<L>
from binary where the original’s
letter type is different than the one specified to be read:
use huff_coding::prelude::{HuffTree, ByteWeights}; let tree = HuffTree::from_weights( ByteWeights::from_bytes(b"abbccc") ); let tree_bin = tree.as_bin(); let new_tree = HuffTree::<u128>::try_from_bin(tree_bin) .expect("this will return a FromBinError");
or when providing a too small/big BitVec to create a HuffTree
use huff_coding::{ bitvec::prelude::*, prelude::{HuffTree, ByteWeights}, }; let tree = HuffTree::<u128>::try_from_bin(bitvec![Msb0, u8; 0, 1]) .expect("this will return a FromBinError (provided BitVec is to small)");
Implementations
impl<L: HuffLetter> HuffTree<L>
[src]
pub fn from_weights<W: Weights<L>>(weights: W) -> Self
[src]
Initialize the HuffTree
with a struct implementing the Weights<L>
trait,
where L
implements HuffLetter
In order to get the tree represented in binary(Bitvec<Msb0, u8>
) you must ensure
that L
also implements HuffLetterAsBytes
Examples
Initialization from ByteWeights
use huff_coding::{ bitvec::prelude::*, prelude::{HuffTree, ByteWeights}, }; use std::collections::HashMap; let tree = HuffTree::from_weights( ByteWeights::from_bytes(b"deefff") ); let codes = tree.read_codes(); assert_eq!( codes.get(&b'f').unwrap(), &bitvec![Msb0, u8; 0] ); assert_eq!( codes.get(&b'e').unwrap(), &bitvec![Msb0, u8; 1, 1] ); assert_eq!( codes.get(&b'd').unwrap(), &bitvec![Msb0, u8; 1, 0] );
Initialization from HashMap<L, usize>
:
use huff_coding::{ bitvec::prelude::*, prelude::{HuffTree, Weights}, }; use std::collections::HashMap; let mut weights = HashMap::new(); weights.insert('ą', 1); weights.insert('þ', 2); weights.insert('😎', 3); let tree = HuffTree::from_weights(weights); let codes = tree.read_codes(); assert_eq!( codes.get(&'😎').unwrap(), &bitvec![Msb0, u8; 0] ); assert_eq!( codes.get(&'þ').unwrap(), &bitvec![Msb0, u8; 1, 1] ); assert_eq!( codes.get(&'ą').unwrap(), &bitvec![Msb0, u8; 1, 0] );
Panics
When trying to create a HuffTree<L>
from a type implementing
Weights<L>
with len == 0:
use huff_coding::prelude::{HuffTree, Weights}; use std::collections::HashMap; let weights = HashMap::<char, usize>::new(); // panics here at 'provided empty weights' let tree = HuffTree::from_weights(weights);
pub fn root(&self) -> &HuffBranch<L>
[src]
Return a reference to the tree’s root branch
pub fn root_mut(&mut self) -> &mut HuffBranch<L>
[src]
Return a mutable reference to the tree’s root branch
pub fn read_codes(&self) -> HashMap<L, BitVec<Msb0, u8>>
[src]
Go down the tree reading every letter’s code and returning
a HashMap<L, BitVec<Msb0, u8>>
Example
use huff_coding::{ bitvec::prelude::*, prelude::{HuffTree, ByteWeights}, }; use std::collections::HashMap; let tree = HuffTree::from_weights( ByteWeights::from_bytes(b"ghhiii") ); let codes = tree.read_codes(); let mut cmp_codes = HashMap::new(); cmp_codes.insert(b'i', bitvec![Msb0, u8; 0]); cmp_codes.insert(b'h', bitvec![Msb0, u8; 1, 1]); cmp_codes.insert(b'g', bitvec![Msb0, u8; 1, 0]); assert_eq!(codes, cmp_codes);
pub fn read_codes_with_hasher<S: BuildHasher>(
&self,
hash_builder: S
) -> HashMap<L, BitVec<Msb0, u8>, S>
[src]
&self,
hash_builder: S
) -> HashMap<L, BitVec<Msb0, u8>, S>
Go down the tree reading every letter’s code and returning
a [HashMap<L, BitVec<Msb0, u8>, S>][HashMap]
where S
is the provided hash builder (implementing BuildHasher
)
Example
use huff_coding::{ bitvec::prelude::*, prelude::{HuffTree, ByteWeights}, }; use std::collections::{ HashMap, hash_map::RandomState, }; let tree = HuffTree::from_weights( ByteWeights::from_bytes(b"ghhiii") ); let codes = tree.read_codes_with_hasher(RandomState::default()); let mut cmp_codes = HashMap::new(); cmp_codes.insert(b'i', bitvec![Msb0, u8; 0]); cmp_codes.insert(b'h', bitvec![Msb0, u8; 1, 1]); cmp_codes.insert(b'g', bitvec![Msb0, u8; 1, 0]); assert_eq!(codes, cmp_codes);
impl<L: HuffLetterAsBytes> HuffTree<L>
[src]
pub fn try_from_bin(bin: BitVec<Msb0, u8>) -> Result<Self, FromBinError<L>>
[src]
Try to read the provided BitVec<Msb0, u8>
and
construct a HuffTree<L>
from it.
Every weight in the newly created tree is set to 0
as they’re not stored in the binary representation
In order to call this method, L
must implement HuffLetterAsBytes
Decoding scheme
- Go bit by bit
- Create a
HuffBranch
with no letter (a joint branch) when a 1 is found - When a 0 is found, read next
size_of::<L>() * 8
bits and create a value of typeL
from them, inserting it then into aHuffBranch
Example
use huff_coding::prelude::{HuffTree, ByteWeights}; let tree = HuffTree::from_weights( ByteWeights::from_bytes(b"mnnooo") ); let tree_bin = tree.as_bin(); let new_tree = HuffTree::try_from_bin(tree_bin).unwrap(); // the newly created tree is identical, except in weights assert_eq!( tree.read_codes(), new_tree.read_codes() ); assert_ne!( tree .root() .leaf() .weight(), new_tree .root() .leaf() .weight() ); // every weight in a HuffTree read from binary is set to 0 assert_eq!( new_tree .root() .leaf() .weight(), 0 );
Errors
When trying to create a HuffTree<L>
from binary where the original’s
letter type is different than the one specified to be read:
use huff_coding::prelude::{HuffTree, ByteWeights}; let tree = HuffTree::from_weights( ByteWeights::from_bytes(b"abbccc") ); let tree_bin = tree.as_bin(); let new_tree = HuffTree::<u128>::try_from_bin(tree_bin) .expect("this will return a FromBinError");
or when providing a too small/big BitVec to create a HuffTree
use huff_coding::{ bitvec::prelude::*, prelude::{HuffTree, ByteWeights}, }; let tree = HuffTree::<u128>::try_from_bin(bitvec![Msb0, u8; 0, 1]) .expect("this will return a FromBinError (provided BitVec is to small)");
pub fn as_bin(&self) -> BitVec<Msb0, u8>
[src]
Return a binary representation of the HuffTree<L>
(BitVec<Msb0, u8>
)
In order to call this method, L
must implement HuffLetterAsBytes
Encoding scheme
- Recurse down the tree
- Every joint branch is encoded as a 1
- Every letter branch is encoded as a 0 and is followed by the letter itself encoded in binary
Example
use huff_coding::prelude::{HuffTree, ByteWeights}; let tree = HuffTree::from_weights( ByteWeights::from_bytes(b"abbccc") ); let tree_bin = tree.as_bin(); assert_eq!(tree_bin.to_string(), "[10011000, 11100110, 00010011, 00010]");
Trait Implementations
impl<L: Clone + HuffLetter> Clone for HuffTree<L>
[src]
impl<L: Debug + HuffLetter> Debug for HuffTree<L>
[src]
Auto Trait Implementations
impl<L> RefUnwindSafe for HuffTree<L> where
L: RefUnwindSafe,
L: RefUnwindSafe,
impl<L> Send for HuffTree<L> where
L: Send,
L: Send,
impl<L> Sync for HuffTree<L> where
L: Sync,
L: Sync,
impl<L> Unpin for HuffTree<L> where
L: Unpin,
L: Unpin,
impl<L> UnwindSafe for HuffTree<L> where
L: UnwindSafe,
L: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Conv for T
impl<T> Conv for T
impl<T> FmtForward for T
pub fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,
Self: Binary,
pub fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,
Self: Display,
pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,
Self: LowerExp,
pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,
Self: LowerHex,
pub fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,
Self: Octal,
pub fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,
Self: Pointer,
pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,
Self: UpperExp,
pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,
Self: UpperHex,
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Pipe for T where
T: ?Sized,
T: ?Sized,
pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
R: 'a,
pub fn pipe_ref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self) -> R
) -> R where
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut Self) -> R
) -> R where
R: 'a,
pub fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized,
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized,
pub fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized,
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized,
pub fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
R: 'a,
U: 'a + ?Sized,
Self: AsRef<U>,
R: 'a,
U: 'a + ?Sized,
pub fn pipe_as_mut<'a, U, R>(
&'a mut self,
func: impl FnOnce(&'a mut U) -> R
) -> R where
Self: AsMut<U>,
R: 'a,
U: 'a + ?Sized,
&'a mut self,
func: impl FnOnce(&'a mut U) -> R
) -> R where
Self: AsMut<U>,
R: 'a,
U: 'a + ?Sized,
pub fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
pub fn pipe_deref_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,
impl<T> Pipe for T
impl<T> PipeAsRef for T
pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,
Self: AsRef<T>,
T: 'a,
R: 'a,
pub fn pipe_as_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
impl<T> PipeBorrow for T
pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,
Self: Borrow<T>,
T: 'a,
R: 'a,
pub fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
impl<T> PipeDeref for T
pub fn pipe_deref<'a, R>(
&'a self,
func: impl FnOnce(&'a Self::Target) -> R
) -> R where
Self: Deref,
R: 'a,
&'a self,
func: impl FnOnce(&'a Self::Target) -> R
) -> R where
Self: Deref,
R: 'a,
pub fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
impl<T> PipeRef for T
pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
R: 'a,
pub fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
R: 'a,
impl<T> Tap for T
pub fn tap(self, func: impl FnOnce(&Self)) -> Self
pub fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self
pub fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Self: Borrow<B>,
B: ?Sized,
pub fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Self: BorrowMut<B>,
B: ?Sized,
pub fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Self: AsRef<R>,
R: ?Sized,
pub fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Self: AsMut<R>,
R: ?Sized,
pub fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
Self: Deref<Target = T>,
T: ?Sized,
pub fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
pub fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
pub fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
pub fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Self: Borrow<B>,
B: ?Sized,
pub fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Self: BorrowMut<B>,
B: ?Sized,
pub fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Self: AsRef<R>,
R: ?Sized,
pub fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Self: AsMut<R>,
R: ?Sized,
pub fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
Self: Deref<Target = T>,
T: ?Sized,
pub fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
impl<T> Tap for T
pub fn tap<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
F: FnOnce(&Self) -> R,
pub fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
F: FnOnce(&Self) -> R,
pub fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
F: FnOnce(&mut Self) -> R,
pub fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
F: FnOnce(&mut Self) -> R,
impl<T, U> TapAsRef<U> for T where
U: ?Sized,
U: ?Sized,
pub fn tap_ref<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Self: AsRef<T>,
F: FnOnce(&T) -> R,
pub fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Self: AsRef<T>,
F: FnOnce(&T) -> R,
pub fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
pub fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
impl<T, U> TapBorrow<U> for T where
U: ?Sized,
U: ?Sized,
pub fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Self: Borrow<T>,
F: FnOnce(&T) -> R,
pub fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Self: Borrow<T>,
F: FnOnce(&T) -> R,
pub fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
pub fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
impl<T> TapDeref for T
pub fn tap_deref<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Self: Deref,
F: FnOnce(&Self::Target) -> R,
pub fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Self: Deref,
F: FnOnce(&Self::Target) -> R,
pub fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
pub fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> TryConv for T
impl<T> TryConv for T
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,