我可以简化处理Option<T>和Result<T>的Rust代码吗？
当然可以！Rust提供了一些功能和技术来简化处理Option<T>和Result<T>的代码。
首先，Option<T>表示一个可能存在或可能不存在的值，而Result<T>表示一个可能成功或可能失败的操作结果。
为了简化处理Option<T>的代码，你可以使用match语句来处理不同的情况。例如，你可以使用match来检查Option<T>是否包含值，并根据情况执行相应的操作。如果Option<T>包含值，你可以使用unwrap()方法来获取该值，如果Option<T>为空，则可以使用unwrap_or()方法来提供一个默认值。
对于Result<T>，你可以使用match语句来处理成功和失败的情况。如果操作成功，你可以使用unwrap()方法来获取结果值，如果操作失败，则可以使用expect()方法来获取错误信息。另外，你还可以使用?运算符来简化错误处理。通过在函数中使用?运算符，你可以将错误传播给调用者，并且在发生错误时立即返回。
除了match语句和?运算符，Rust还提供了其他一些方法来简化处理Option<T>和Result<T>的代码。例如，你可以使用map()方法来对Option<T>或Result<T>中的值进行转换，使用and_then()方法来处理连续的操作，使用unwrap_or_else()方法来提供一个处理函数，等等。
总之，Rust提供了丰富的功能和技术来简化处理Option<T>和Result<T>的代码。通过合理使用这些方法，你可以编写更简洁和可读性更高的代码。
关于腾讯云相关产品和产品介绍链接地址，以下是一些推荐的产品：
- 云服务器（CVM）：提供弹性的云服务器实例，适用于各种应用场景。详情请参考：https://cloud.tencent.com/product/cvm
- 云数据库 MySQL 版（CDB）：提供高性能、可扩展的云数据库服务，适用于各种规模的应用。详情请参考：https://cloud.tencent.com/product/cdb_mysql
- 云原生容器服务（TKE）：提供高度可扩展的容器化应用管理平台，支持快速部署和管理容器化应用。详情请参考：https://cloud.tencent.com/product/tke
请注意，以上链接仅供参考，具体产品选择应根据实际需求进行评估和决策。
相关·内容
我正在学习Rust，我正在为可选的URL解析而苦苦挣扎，我得到了以下代码：
use hyper::Uri;
fn main() -> Result<(), String> {
let url = Some("http://www.stackoverflow.com");
let works = if let Some(url) = url {
Some(parse_url(url)?)
} else {
None
};
let does_not = url.map(|u| parse
浏览 10提问于2020-05-21得票数 1
回答已采纳
我浏览了Rust中一些基本类型背后的代码，例如Option<T>的或tuple背后的，我能够在中找到我想要的所有类型。除了一个- bool。我在别的地方也找不到它。
Rust中bool背后的代码在哪里？我知道这不是最新奇的类型，但我很惊讶我找不到它。
感谢Francis和rodrigo的回答，我注意到我为其他原语找到的代码只是它们的特征和相关的宏，而不是实际的实现。
Rust的书说原语是的，但我对这种解释并不满意。它们是什么时候内置的？它可以追溯到Rust编译器第一次用Rust构建的时候吗?还是在它还是用OCaml构建的时候发生的？是否存在相关代码？
浏览 2提问于2016-09-06得票数 12
回答已采纳
我想在铁锈函数中添加一些错误处理程序，所以我像这样定义了锈蚀函数响应，这样如果包含可恢复的错误，我就可以返回错误消息：
pub fn add_bill_book() -> Result<BillBook,String> {
return Err("failed".parse().unwrap())
}
并像这样把结果放回客户；
fn main() {
let result = add_bill_book();
box_rest_response(result);
}
但是，当我编译该项目时，会显示如下错误：
➜ rust-le
浏览 1提问于2022-06-09得票数 1
回答已采纳
1回答
我将libxml2包装在Rust中作为学习Rust FFI的练习，我遇到了一些奇怪的事情。我是Rust的新手，但我相信下面的方法应该会起作用。
在main.rs中，我有：
mod xml;
fn main() {
if let doc = xml::parse_file("filename") {
doc.simple_function();
}
}
xml.rs是：
extern create libc;
use libc::{c_void, c_char, c_int, c_ushort};
use std::ffi::CString;
浏览 4提问于2016-07-30得票数 2
回答已采纳
1回答
我正在尝试使 + 库堆栈正常工作。火箭随一起打包，它允许使用创建特定于应用程序的配置文件。
使用此示例，我创建了一个泛型反序列化器，以允许我的(yaml)配置将字符串(如log_level: "debug" )映射到跟踪库日志。下面实现这一点的代码工作得很好。但是，如果对配置文件进行了修改以删除log_level，则会由于以下错误而中断：
thread 'main' panicked at 'Broken!: Error { tag: Tag(Default, 5), profile: Some(Profile(Uncased { string:
浏览 1提问于2021-09-21得票数 1
回答已采纳
我有一个通用结构，但我有一个问题。
#[derive(Debug,Clone,Serialize,Deserialize)]
pub struct Item<T> {
pub edges: Option<Vec<T>>
}
impl<T> Item<T> {
pub fn to_result(self) -> Option<T>{
match self.edges {
Some(edges) =>{
if
浏览 2提问于2020-06-14得票数 1
回答已采纳
2回答
我只是撞到墙上了。假设我的代码如下所示：
def foo
if bar
123
else
nil
end
end
这里的返回值要么是Int，要么是Nil。我已经习惯了选项词的概念(用Rust，F#，Haskell等语言)，这让我很困惑。
我意识到，我可以毫无问题地返回任何类型的值，但是从一个功能更强的背景来看，我觉得这是错误的。
在铁锈，我会返回一个Option<T>。这样，我就可以很容易地测试Some值是否返回，或者没有值(None)。但是，在Ruby/Crystal中，这似乎是一件愚蠢的事情。
所以，问题是：
如果没有有用
浏览 4提问于2016-12-21得票数 1
回答已采纳
1回答
我是rust的新手，我写了一个函数，它返回一个带有Box dyn错误的结果。 use std::error::Error;
fn func(val: T) -> Result<(), Box>
where
T: std::fmt::Debug,
{
println!("{:?}", val);
Ok(())
}
fn main() {
func("hello world");
} 在这里，我没有在函数中编写任何错误逻辑func但它仍然有效。上面的代码会自动捕获所有错误吗？类似于python的 try
浏览 30提问于2021-02-24得票数 2
回答已采纳
在编写必须返回值的函数时，有两种类似的方法：
#1 (从中提取)
// An integer division that doesn't `panic!`
fn checked_division(dividend: i32, divisor: i32) -> Option<i32> {
if divisor == 0 {
// Failure is represented as the `None` variant
None
} else {
// Result is wrapped in a `Some
浏览 2提问于2016-02-06得票数 0
回答已采纳
我对Rust很陌生，我想减少代码的嵌套。以这个C#代码为例：
for (int i = 0; i < 100; i++)
{
var obj = arr[i];
if (obj != null)
{
var something = obj.Something;
if (something == null)
{
if (i % 3 == 0)
Console.WriteLine(i);
break;
}
}
}
Re
浏览 2提问于2016-01-29得票数 3
回答已采纳
#![allow(non_camel_case_types)]
use libc::{c_uchar, size_t};
use std::str::FromStr;
use std::ffi::{CString, NulError};
use std::slice;
#[repr(C)]
pub struct c_str_t {
pub len: size_t,
pub data: *const c_uchar,
}
pub trait MyCStrExt<T> {
fn to_c_str(&self) -> Result<c_s
浏览 1提问于2018-01-13得票数 1
回答已采纳
1回答
我是生锈新手，只是摸了摸。我正在尝试实现一个通用队列，没有生产原因，只是熟悉了这个语言。
我有：
pub struct Queue<T> {
container: Vec<T>,
}
impl<T> Queue<T> {
pub fn new() -> Self {
Queue {
container: Vec::new(),
}
}
pub fn enqueue(&mut self, item: T) {
self.cont
浏览 1提问于2020-06-23得票数 1
回答已采纳
我对Rust非常陌生，我的第一个“严肃”项目涉及使用PyO3为一个小型锈蚀库编写Python包装器。这基本上是无痛的，但我很难解决如何将锈蚀Vec上的懒惰迭代器暴露给Python代码。
到目前为止，我一直在收集迭代器产生的值并返回一个列表，这显然不是最好的解决方案。这里有一些代码说明了我的问题：
use pyo3::prelude::*;
// The Rust Iterator, from the library I'm wrapping.
pub struct RustIterator<'a> {
position: usize,
view:
浏览 3提问于2020-05-22得票数 11
我有一个C代码：
typedef void (*f_t)(int a);
struct Foo {
f_t f;
};
extern void f(struct Foo *);
生成以下锈蚀代码(我已经删除了不重要的详细信息)：
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct Foo {
pub f: ::std::option::Option<extern "C" fn(a: ::std::os::raw::c_int)>,
}
我不明白为什么Option会在这
浏览 3提问于2016-08-17得票数 3
回答已采纳
这可能不是一个高质量的问题，因为我是生疏。
我和一起工作。火箭处理程序可以返回“实现Responder特性的任何类型的值”。但是，我注意到我可以将实现Responder的东西封装在任意数量的Results或Option中，并且看起来是可行的。例如：
#[post("/add_data")]
fn add_data() -> std::result::Result<Option<Response<'static>>, Status> {
Ok(Some(Response::new()))
}
当然，火箭没有处理所有这些不同
浏览 6提问于2020-12-29得票数 3
回答已采纳
我是Rust的新手，当我尝试在“Rust编程语言”中运行“清单12-9:从Config：：new返回结果”的代码时，出现了3个错误，但我不知道如何修复它们。 下面是信息： {
"resource": "/d:/Document/Code/Rust/minigrep/src/main.rs",
"owner": "rust-file:///d%3A/Document/Code/Rust/minigrep",
"code": "E0609",
"severity
浏览 12提问于2021-02-06得票数 0
回答已采纳
我的处境如下：
fn some_fn<K, T, F, S>(func: F, other_func: S) -> Vec<i64>
where
K: SomeType<T>,
T: SomeOtherType,
F: Fn() -> (),
S: Fn() -> (),
{
//...
}
对于上述示例，Rust可以正确推断T、F和S类型，但不能推断K (如预期的那样)。
是否有一种方法仅在调用some_fn时指定some_fn的类型，而不同时指定T、F和S
我目前的解决办法是将签名更改为some_
浏览 2提问于2022-07-28得票数 1
回答已采纳
1回答
我试图编写一个库，它必须打开文件，并且我想处理std::fs::File::create使用的std::fs::File::create类型。考虑到这个包装器函数，我不知道如何匹配返回结果：
use std::fs::File;
use std::path::Path;
use std::fs::File;
use std::path::Path;
pub fn allocate(path:& str) -> File{
let mut file = File::create(Path::new(path));
}
然后调用：
mod whisper;
use std::i
浏览 4提问于2015-03-25得票数 1
回答已采纳
我有一条生锈方法错误消息：
error[E0277]: the `?` operator can only be used on `Option`s,
not `Result`s, in an async function that returns `Option`
我必须承认，我经常会遇到令我感到困惑的锈蚀错误信息，而对大多数其他编码者来说，它们是绝对合理的。
因此，我为张贴这个问题而事先表示歉意。
首先:错误消息中的第二个逗号是什么意思？我是否应将其阅读如下：
“如果另一个函数中的异步函数调用返回类型为Result的枚举，则只能在相应的其他函数返回Result类型的枚举而不是Option类
浏览 18提问于2022-11-22得票数 2
回答已采纳
我是生锈新手！从Option<T>到Result<T, ()>的最佳转换方法是什么？
特性似乎很普遍，并返回一个结果。流行的num_traits‘有许多转换，但它们都返回一个Option<T>。类似地，Rust标准库中的非零*构造函数(如 )也是如此。然后我注意到NumCast实现了一个返回Option<T>的from()，所以我想也许它通常有一种非标准的方法，但是后来我看到了非零*实现，并对这个想法提出了质疑。
无论如何，从选项到结果的转换似乎很频繁，而且我还没有找到一个很好的方法。例如：
/// Add common conversion f
浏览 2提问于2020-04-19得票数 8
回答已采纳
在锈病中，Option被定义为：
pub enum Option<T> {
None,
Some(T),
}
使用方式如下：
fn may_return_none() -> Option<i32> {
if is_full_moon {
None
} else {
Some(1)
}
}
fn main() {
let optional = may_return_none();
match optional {
None => println!("
浏览 1提问于2017-03-30得票数 8
回答已采纳
1回答
月中日解
、
用Rust编写的代码解决了月中日问题在CodeChef中的问题。这也是我第一批用锈写的程序之一。
代码被接受，这样就不会有逻辑错误。我更感兴趣的是获得关于风格的评论反馈。我对代码并不特别满意，因为它相当笨重。
use std::io;
fn read_line(stdin: &io::Stdin) -> io::Result<String>
{
let mut input = String::new();
match stdin.read_line(&mut input)
{
Ok(_) => Ok(input.
浏览 0提问于2018-01-02得票数 4
1回答
我是生锈新手，目前一直在跟随的例子。在IterMut部分之前，一切对我来说都是有意义的。然而，在实现IterMut(与教程不同的方式)时，我被Rust中的终身机制完全搞糊涂了。如下所示，首先，我只需要定义要实现的堆栈：
pub struct List<T> {
head: Link<T>,
}
type Link<T> = Option<Box<Node<T>>>;
struct Node<T> {
elem: T,
next: Link<T>,
}
那么，当我尝试以以下
浏览 13提问于2022-05-02得票数 1
回答已采纳
2回答
我正在尝试捕获Rust上的错误，但如果我找到它，我不希望程序退出。我对Rust很陌生。基本上，我希望从Windows注册表中找到一个键，如果它不存在，则创建它。 我使用的是一个名为winreg的板条箱。 这将是我的程序的一部分： fn main() -> io::Result<()> {
...
...
...
key.set_value("TestSZ", &"written by Rust")?;
// here I'm getting a value that exists
浏览 40提问于2021-08-25得票数 1
我正在尝试构建一个操作递归(树状)数据结构的Rust代码。天真地，我们可以把它定义为
struct ALinkedList {
value: i32,
next: Option<Box<Self>>
}
为了试验不同的内存布局和将算法设计与存储分开，我想将定义概括为如下
struct ALinkedList<D: Deref<Target=Self>> {
value: i32,
next: Option<D>
}
但是，当试图构造ALinkedList实例时，我得到
64 | let t: A
浏览 4提问于2020-12-25得票数 3
回答已采纳
如果Rust的Option提供了一些额外的方便方法，比如Option#flatten和Option#flat_map，那么flatten会将<Option<Option<T>>还原为Option<T>，flat_map会像map一样工作，但采用返回Option并将其扁平化的方法/闭包，那就太好了。
flat_map非常简单：
fn opt_flat_map< T, U, F: FnOnce(T) -> Option<U> >(opt: Option<T>, f: F) -> Option<U>
浏览 13提问于2015-02-17得票数 9
回答已采纳
2回答
我希望下面的kotlin代码能够工作：
val result: Try<Option<String>> = Success(Some("test"))
val test = when {
result is Success && result.value is Some -> result.value.t // not working
result is Success && result.value is None -> "Empty result"
result i
浏览 0提问于2019-02-14得票数 2
回答已采纳
2回答
在Rust中，我认为处理可恢复错误的惯用方法是使用Result。例如，此函数显然是惯用的：
fn do_work() -> Result<u64, WorkError> {...}
当然，也有一些函数具有单一的、明显的故障状态，因此使用Option类型。一个惯用的例子是：
fn do_work() -> Option<u64>
这一切都在文档中得到了直接的解决。然而，我对这样的情况感到困惑:函数可能会失败，但在成功时却没有任何意义。比较以下两个函数：
fn do_work() -> Option<WorkError>
// vs
fn do
浏览 11提问于2016-04-27得票数 44
回答已采纳
1回答
这段简单的代码快把我逼疯了：
pub fn load_any<'a, T, K>(&self, key: K) -> Result<Option<T>, kv::Error> where
T: 'a + Persistent + Debug + Serialize + for<'de> Deserialize<'de>,
K: 'a + kv::Key<'a>,
{
let bucket = self.store.bucket::<
浏览 0提问于2021-03-17得票数 2
此代码()
object Main extends App {
import scala.util.Try
case class Result[T](value :T)
def hi() = "hi"
def safer[T](f : () => T) : Try[Result[Option[T]]] = {
Try(hi)
.map((r) => Result(Some(r)))
.orElse(Try(Result(None)))
}
saf
浏览 6提问于2015-09-02得票数 1
回答已采纳
我刚开始学习Rust，但是自从升级到beta版本之后，我面临着许多以前没有的编译错误。其中一个与clone相关，下面是我的代码：
use std::io::{BufReader, BufRead};
use std::clone::Clone;
use std::env;
use std::fs::File;
pub fn main() {
let ref path = match env::args().nth(1) {
Some(path) => path,
None => panic!("file path
浏览 3提问于2015-05-03得票数 2
回答已采纳
3回答
我在Java中定义了一个类型的Option<T>，它的行为应该尽可能多地与Rust的等价物一致。
它有一个方法，它只有在内部T是其他Option<T>的情况下才实现。我在想这样的事情：
public class Option<T> {
/* fields, constructors, other methods */
@Bound(T=Option<U>)
public <U> Option<U> flatten() {
if (isNone()) return None();
浏览 11提问于2022-08-22得票数 1
我正在努力学习Rust，就像我之前的许多人一样，我开始编写一个Fibonacci序列迭代器进行练习。我的第一次通过使用了u32，并且运行良好，所以我决定尝试编写一个通用版本。这是我的结果：
use num::Integer;
use std::ops::Add;
pub struct Fibonacci<T: Integer + Add + Clone> {
nth: T,
n_plus_one_th: T,
}
impl<T: Integer + Add + Clone> Iterator for Fibonacci<T> {
浏览 1提问于2016-12-05得票数 11
回答已采纳
我有一个函数，它试图从Refcell返回一个Ref。引用位于Option后面，如果Option为None，我希望能够返回引用或错误。 目前，我正在预先检查它是否没有，如果是，则返回一个错误。然后，我在Ref::map中的选项上调用unwrap()，以便返回对象。 有没有更符合人体工程学的方法？这样做似乎非常烦人(multiple borrows()等) Option有一个方法ok_or可以将其转换为结果类型。有什么方法可以在这里使用吗？ 下面是一个重现最小示例的Rust playground： pub fn get_thing_convenience(&self) ->
浏览 14提问于2020-06-17得票数 2
我正在包装一个锈蚀的东西，要从Lua那里用。当Rust代码和Lua仍然没有引用时，我需要销毁对象，所以显而易见的(对我来说)解决方案是使用Rc<T>，存储在Lua管理的内存中。
Lua (我现在使用的是 )允许您分配一块内存，并将方法和终结器附加到其中，因此我希望将一个Rc<T>存储到该内存块中。
我现在的企图是。首先，创建一个对象：
/* Allocate a block of uninitialized memory to use */
let p = state.new_userdata(mem::size_of::<Rc<T>>() as
浏览 0提问于2016-03-10得票数 5
回答已采纳
我正在学习Rust (我来自Java)，我遇到了一些问题。我正在构建一个简单的程序，它是连接池的基础。当我运行它时，我得到了运行时错误thread 'main' has overflowed its stack，我不明白为什么。
这是main.rs
use hello_rust::concurrent_bag;
use hello_rust::concurrent_bag::BagEntry;
fn main() {
let my_bagentry = BagEntry::new(String::from("ciao"));
//println
浏览 48提问于2020-02-09得票数 1
回答已采纳
新来的铁锈！目前，我正在使用TOML库来读取TOML配置.
请参阅
下面是我从toml示例/decde.rs中获取的代码，并更新了代码
use serde::Deserialize;
use toml;
#[derive(Debug, Deserialize)]
struct Config {
active_users: Vec<String>,
// john: Option<User>, - i don't want to manually add each line for all tables
}
#[derive(Debug, De
浏览 3提问于2022-09-16得票数 2
3回答
假设我们有以下定义，我不明白为什么TypeScript仍然不能正确推断类型！
有人知道如何正确地编写它吗？
备注：
*确保打开"Strict Null Check“选项。
*我注释了代码来解释这个问题，如果不清楚请评论。
type Diff<T, U> = T extends U ? never : T;
type NotNullable<T> = Diff<T, null | undefined>;
type OptionType<T> = T extends NotNullable<T> ? 'some'
浏览 0提问于2018-08-13得票数 4
在Rust文档中，我看到像这样的实现，来自
impl<T> Copy for Option<T> where T: Copy + Copy
Copy + Copy界限是什么意思？这只是一个文档的怪癖吗？
浏览 3提问于2015-08-18得票数 2
回答已采纳
在更新到最新的Rust版本之前，可以使用以下内容：
fn example(val: &[&str]) {
let parsed_value: Vec<usize> = val
.iter()
.filter_map(|e| e.parse::<usize>())
.collect();
}
但是，现在解析方法返回的是Result类型而不是Option类型，并且我得到了错误：
error[E0308]: mismatched types
--> src/lib.rs:4:25
|
4 |
浏览 0提问于2015-02-18得票数 45
回答已采纳
2回答
原始问题
这段代码与我正在尝试修复的代码段比较相似。我也在上问过这个问题。
/// assume this function can't be modified.
fn foo<A>(
f1: impl Fn(&str) -> Result<(&str, A), ()>,
base: &str,
f2: impl Fn(A) -> bool
) {
let s: String = base.to_owned();
let option = Some(s.as_ref());
l
浏览 2提问于2020-05-06得票数 0
我正在尝试在Rust中实现一个B-Tree类，它可以在各种不同的b值上实例化。我已经尝试了以下代码：
struct BTreeNode<T, b> {
vals: [Option<T>; b-1],
children: [Option<Box<BTreeNode<T, b>>>; b],
}
struct BTree<T, b> {
root: Option<BTreeNode<T, b>>,
}
但是编译器(合理地)抱怨说
src/two_three_tree.rs:2:
浏览 0提问于2016-04-16得票数 0
我正在做我的任务，包括与Rust中的数据库建立连接。我正在使用最新版本的mysql crate:当我打印池变量时，mysql ="18.2.0".My数据库连接成功。我为表学生编写了自己的代码，但我得到了错误。然后我粘贴了文档的代码，我收到了以下错误，并显示“？”运算符： 我第一次在rust中连接数据库。任何帮助都是非常感谢的。 warning: unused import: `std::io`
--> src/main.rs:2:5
|
2 | use std::io;
| ^^^^^^^
|
= note: `#[warn(unused_i
浏览 98提问于2020-06-27得票数 2
回答已采纳
我试图在我的C++代码库中嵌入一个小锈库，我使用货-c(我认为它使用cbindgen ?)为了创建一些简单的锈病C api，锈病侧api如下所示：
#[no_mangle]
pub extern "C" write_result_to_cpp_callback(
cpp_callback : Option<extern "C" fn( i64 )>)
(它基于回调，而不是返回值，因为锈迹部分实际上运行tokio运行时来执行io任务，并且任何对锈迹的调用都是非阻塞的)
现在我需要传递一些复杂的结构，而不是简单的i64，似乎cxx.rs使这更简
浏览 6提问于2022-10-03得票数 1
因为我是Rust的新手，所以我需要关于如何以惯用的方式完成错误处理的指导。我发现错误处理样板真的很烦人。
我被多个Option<T>卡住了，手动处理每个None的情况太繁琐了。
例如，在Haskell中，您可以将可选值(Maybe)操作与各种运算符链接在一起：fmap、<*>、>>=等：
f x = x * x
g x = x ++ x
main = print $ g <$> show <$> f <$> Just 2
在Rust中，同样的情况看起来是不可能的。我正在尝试将一个两个字符的卡片字符串解析为一个结构Card
浏览 95提问于2018-06-07得票数 10
回答已采纳
我正在用Rust构建一个库，它有一个send方法，可以使用reqwest在本地RPC服务器上执行HTTP请求。
此方法在Result where R: DeserializeOwned中返回泛型类型R。在为每个响应创建正确的类型之后，serde_json::from_str()可以为我提供类型。
如果请求没有响应，如何让send仍然返回有意义的内容？
这是我现在拥有的代码：
fn send<R, T>(
&self,
request: &RpcRequest<T>,
) -> Result<R, ApiError>
浏览 0提问于2019-02-07得票数 0
使用unwrap很容易在运行时崩溃
fn main() {
c().unwrap();
}
fn c() -> Option<i64> {
None
}
结果：
Compiling playground v0.0.1 (file:///playground)
Running `target/debug/playground`
thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', ../src/libcore/option.rs:
浏览 0提问于2016-09-13得票数 30
回答已采纳
鉴于以下方案：
use std::collections::HashMap;
fn main() {
let mut hm = HashMap::new();
hm.insert(0, 1);
hm.insert(1, 1);
let mut iter = hm.iter();
println!("{:?}", iter.nth(0).expect("Fatal.").0)
}
每次执行代码，我都会得到不同的输出：
procyclinsur@procyclinsur:~/Documents/Rust/t1$ cargo
浏览 0提问于2018-05-08得票数 4
回答已采纳
2回答
我试图想出一种“优雅”的方法，用递归和回忆法(自我强加的要求)来计算Rust中的数字斐波纳契。
到目前为止，这就是我所拥有的：
fn fib(n: usize, memo: &mut [Option<usize>]) -> usize {
memo[n].map(|v| v).unwrap_or_else(|| {
let result = {
if n > 1 {
fib(n - 1, memo) + fib(n - 2, memo)
} else {
浏览 0提问于2018-09-28得票数 12
回答已采纳
我在rust的推荐信上遇到了点麻烦。我有以下不能编译的代码：
use std::collections::HashMap;
fn main() {
let mut map = HashMap::new();
map.insert(&0, &0);
map.insert(&1, &1);
assert_eq!(map.get(&0), Some(&0));
}
我得到的编译错误是：
error[E0308]: mismatched types
--> rust_doubt.rs:9:5
|
9 |
浏览 106提问于2019-03-04得票数 4
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
