内容简介:Rust’s generics give us a whole lot of flexibility. A method that takes a trait bound argument does not need to care about the actual type of the argument it is called with. For example:However, this will monomorphize the method: For eachThis makes each ca
Rust’s generics give us a whole lot of flexibility. A method that takes a trait bound argument does not need to care about the actual type of the argument it is called with. For example:
fn parse_read(r: impl Read) -> MyParseableType { todo!(); }
However, this will monomorphize the method: For each Read
instance,
one instance will be created, potentially ballooning up the code size
and increasing compile time. But Rust gives us dynamic dispatch, too,
e.g.
fn parse_read(r: &mut dyn Read) -> MyParseableType { todo!(); }
This makes each call on r
dynamic
. Only one version of this method
needs to be created, but whenever r
’s methods are called, the method
must be looked up at runtime. This is done by having one static
data
per type that tells us where to find the respective methods. This
so-called
vtable
is referenced whenever we need dynamic dispatch.
Now let’s say we want to pass our Read
instance through to the
method. For our example, we want to use Stdin
or some File
.
let readable = todo!(); parse_read(readable)
How should we initialize readable
? The novice’s initial attempt is
foiled by the type system:
let readable = if arg == "-" { io::stdin() } else { fs::File::open(arg)? };
The type checker is having none of it.
error[E0308]: if and else have incompatible types --> src/main.rs:5:9 | 2 | let readable = if arg == "-" { | _____________________- 3 | | std::io::stdin() | | ---------------- expected because of this 4 | | } else { 5 | | std::fs::File::open(arg)? | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected struct `std::io::Stdin`, found struct `std::fs::File` 6 | | }; | |_____- if and else have incompatible types error: aborting due to previous error
Now the novice asks around and finds that Box
es can hold dynamic
types.
let readable = if arg == "-" { Box::new(io::stdin()) } else { Box::new(fs::File::open(arg)?) };
This still doesn’t work, because we haven’t told the compiler to make the type dynamic. And alas, the error message isn’t quite helpful. We can annotate the type to make it work:
let readable: Box<dyn io::Read> = if arg == "-" { Box::new(io::stdin()) } else { Box::new(fs::File::open(arg)?) };
Box
can have a little dynamic dispatch, as a treat. This will store
the vtable
pointer along with our Read
instance in the Box
’s
allocated memory.
However, we are Rustaceans, so we don’t want to Box
to get dynamic
dispatch. What we need are two places to hold our Read
instances that
live long enough to use them:
// these must live longer than `readable` let (mut stdin_read, mut file_read); let readable: &mut dyn io::Read = if arg == '-' { stdin_read = io::stdin(); &mut stdin_read } else { file_read = fs::File::open(arg)?; &mut file_read };
The readable is out of the box! What happens is that we declare two
stack slots that may alternately stay uninitialized or used, depending
on arg
. Then we take a &mut dyn
mutable dynamic reference on it,
which means the type will have a non-null pointer to the object (either stdin_read
or file_read
, depending on the branch taken) and a
second reference to the vtable
of either the Stdin
type or the File
type.
As an aside, this technique can also be used to create an Option<&T>
where we don’t want to initialize the T
unless needed:
let t_holder; let opt_t = if has_t { t_holder = get_t(); Some(&t_holder) } else { None }
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持 码农网
猜你喜欢:本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们。
深入理解TensorFlow:架构设计与实现原理
彭靖田、林健、白小龙 / 人民邮电出版社 / 2018-5-1 / 79.00元
本书以TensorFlow 1.2为基础,从基本概念、内部实现和实践等方面深入剖析了TensorFlow。书中首先介绍了TensorFlow设计目标、基本架构、环境准备和基础概念,接着重点介绍了以数据流图为核心的机器学习编程框架的设计原则与核心实现,紧接着还将TensorFlow与深度学习相结合,从理论基础和程序实现这两个方面系统介绍了CNN、GAN和RNN等经典模型,然后深入剖析了TensorF......一起来看看 《深入理解TensorFlow:架构设计与实现原理》 这本书的介绍吧!