假设我需要解析一个二进制文件,该文件以三个4字节幻数开头.其中两个是固定字符串.然而,另一个是文件的长度.
{-# LANGUAGE OverloadedStrings #-}
module Main where
import Data.Attoparsec
import Data.Attoparsec.Enumerator
import Data.Enumerator hiding (foldl, foldl', map, head)
import Data.Enumerator.Binary hiding (map)
import qualified Data.ByteString as S
import System
main = do
f:_ <- getArgs
eitherStat <- run (enumFile f $$ iterMagics)
case eitherStat of
Left _err -> putStrLn $ "Not a beam file: " ++ f
Right _ -> return ()
iterMagics :: Monad m => Iteratee S.ByteString m ()
iterMagics = iterParser parseMagics
parseMagics :: Parser () …我有一个对象，希望每个日志记录输出都以该对象的某些状态为前缀。但是为每个日志记录语句添加前缀非常不便。有没有简单的实现方法？
下面是示例代码。
use log::info;
struct Obj {
id: i32,
name: String,
}
impl Obj {
// can I use `info!("receive {} from {}", item, from);` for simplicity?
fn call_me(&self, item: i32, from: String) {
info!("[id: {}][name: {}] receive {} from {}", self.id, self.name, item, from);
}
// ...many methods
}
任何帮助将不胜感激！
我想获得向量元素的所有组合。我正在使用 itertools 的组合（）函数。很好，但现在我想操纵向量的元素。因此我需要一个迭代器来生成向量元素的可变引用......
我的代码基本上如下所示：
let mut v: Vec<MyType> = vec![];
for vpair in v.iter_mut().combinations(2) {
vpair.first().unwrap().do_something(vpair.last().unwrap());
}
通过调用我想在每次迭代中do_something()操作vpair.first().unwrap()and 。vpair.last().unwrap()
我收到的错误是：
the trait std::clone::Clone is not implemented for &mut MyType
我能以某种方式解决这个问题还是我完全走错了路？
在Rust 0.8中:
struct TwoStr {
one: ~str,
two: ~str,
}
#[test]
fn test_contents() {
let strs = TwoStr {
one: ~"pillar",
two: ~"post",
};
assert_eq!(strs.one, ~"pillar");
assert_eq!(strs.two, ~"post");
}
代码甚至不会编译.在rust test认为有一个在第二的错误assert_eq:
错误:使用部分移动的值:
strs
这有点违反直觉.我的意思是,无论第一个assert_eq有什么影响,当执行到达第二个时,它应该远远超出范围assert_eq.除非当然,它会在场景后面产生一些东西.可以？
如果没有,为什么这个神秘的错误呢？希望我对Rust指针的理解没有根本的缺陷.
我理解这个错误，但仍然不知道如何转换i为u32/integer.
let n = 2;
for i in [1..10].into_iter() {
if n % i == 0 {
...
}
}
if n % (i as u32) == 0不起作用
帮助：该特征
std::ops::Rem<&std::ops::Range<{integer}>>未实现{integer}
我是 Rust 新手，我正在尝试找出在 Rust 中执行以下操作的最佳方法是什么：
struct ThingIterator {
current: String,
stop: String,
}
impl Iterator for ThingIterator {
type Item = &str;
fn next(&mut self) -> Option<&str> {
if self.current == self.stop {
return None;
}
// For testing
self.current = self.stop;
Some(&self.current)
}
}
fn main() {
let pi = ThingIterator {
current: String::from("Ask"),
stop: String::from("Zoo"),
};
println!("Number of things={}", pi.count());
}
我的错误是：
error[E0106]: missing lifetime specifier
--> src/main.rs:7:17
|
7 | type Item = &str;
| ^ expected …libc 有一个函数返回一个不应该是 free()d 的字符串。可以读取用户当前目录，/etc/passwd但不应是 free()d。如果我从指针创建一个字符串，程序会立即中止
free(): invalid pointer
Aborted (core dumped)
显然，代码是不安全的。
let pw = libc::getpwnam(username.as_ptr() as *const i8);
let cd = (*pw).pw_dir;
let len = libc::strlen(cd);
builder.current_dir(String::from_raw_parts(cd as *mut u8, len, len));
我可以mem::forget(s)使用字符串，但会泄漏内存，至少长度必须存储在某处。我只需要防止释放底层原始字节。项目是一个服务器，所以我不能忽视泄漏。
我正在使用reqwest使用以下函数在API上进行get请求：
async fn get_item_response(client: &Client, id: &str) -> Result<Response, reqwest::Error> {
let base = "http://someurl.com/item?={item_id}"
.replace("{item_id}", id);
client.get(&base).send()
}
async fn main() -> Result<(), Box<dyn Error>> {
let client = Client::new();
let response = get_item_response(&client, "1").await?;
}
响应是响应类型，而不是结果，这意味着如果不惊慌，我将无法检查是否发生了错误。有没有办法访问结果？
我在这里遇到 Rust 编译器问题。这段代码最初是用 C 编写的，我的工作是将其移植到 Rust 代码中。我不会在这里修改算法或任何内容，但 Rust 编译器比 C 编译器更严格，并且它标记了完全有效的代码。
error[E0381]: borrow of possibly-uninitialized variable: `output_file_handler`
--> src/main.rs:318:9
|
318 | output_file_handler.write(b"Why won't it work?");
| ^^^^^^^^^^^^^^^^^^^ use of possibly-uninitialized `output_file_handler`
error: aborting due to previous error
我正在编写的这个程序使用 Rust 的 MPI 库，但现在让我们忽略它，因为它不是我的问题的一部分。
问题是，我File在函数顶部声明了一个可变对象main()，但在开始时未初始化。现在因为我使用的是 MPI，所以这是一个多进程程序。我正在对此进行一些简化，并删除对我的问题来说不必要的代码。
my_rank变量基本上保存当前正在执行的进程的“进程ID”，因为相同的代码可以由多个进程运行。进程my_rank == 0只负责将输出打印到文件，其他进程都不执行此操作。在 的进程中my_rank == 0，output_file_handler是“活动的”，而在其他进程中，它保持未初始化状态，只是从未使用过。
除了声明之外，所有对 的访问都output_file_handler在进程中my_rank == 0，因此它在使用时总是被初始化。然而，编译器太愚蠢而无法意识到这一点，而且太严格，因此它会惩罚完美的代码！
首先我有 的声明output_file_handler。然后我有一些代码启动 MPI 子系统并“分叉”一堆进程，并为每个进程分配其各自的等级。然后在之后 …
我有一个包含两个字段state和children的结构体。Children 是一个包含孩子向量的选项。我正在使用 if let 语法将此选项解构回向量。
fn main() {
let mut root = Node::new2d(3);
loop {
root.calc_scores(100);
if let Some(mut children) = root.children {
let child = children.pop();
root = Node {
state: child.0,
children: None,
}
}
root.make_children();
}
}
struct Node<T> {
state: T,
children: Option<Vec<(T, i32)>>,
}
上面的代码不能编译。它抱怨 child 是 类型Option<(Board2d,i32)>。为什么 child 仍然包含在选项枚举中？不会if let Some(mut children) = root.children{}从 Option 枚举中取出向量吗？