小编Ben*_*ijl的帖子

我有一个具有以下结构的枚举:

enum Expression {
    Add(Add),
    Mul(Mul),
    Var(Var),
    Coeff(Coeff)
}

每个变体的"成员"都是结构.

现在我想比较两个枚举是否有相同的变体.所以,如果我有

let a = Expression::Add({something});
let b = Expression::Add({somethingelse});

cmpvariant(a, b)应该是true.我可以想象一个简单的双重match代码,它遍历两个枚举实例的所有选项.但是,如果它存在,我正在寻找一个更好的解决方案.如果没有,双重匹配会有开销吗？我想在内部我只是比较两个整数(理想情况下).

我在下面有一个简单的"工作"示例,每两秒打开一次谷歌连接.当我有一个有效的互联网连接时运行这个脚本,我得到了成功消息,然后当我断开连接时,我收到失败消息,当我再次重新连接时,我再次获得成功.到现在为止还挺好.

但是,当我在断开互联网时启动脚本时,我会收到失败消息,当我稍后连接时,我从未收到成功消息.我一直收到错误:

urlopen错误[Errno -2]名称或服务未知

到底是怎么回事？

import urllib2, time

while True:
    try:
        print('Trying')
        response = urllib2.urlopen('http://www.google.com')
        print('Success')
        time.sleep(2)
    except Exception, e:
        print('Fail ' + str(e))
        time.sleep(2)

我想提取一个匹配模式的子字符串并将其保存到文件中.示例字符串:

Apr 12 19:24:17 PC_NMG kernel: sd 11:0:0:0: [sdf] Attached SCSI removable disk

在这种情况下,我想在括号之间提取部分[sdf].

我试图grep -e '[$subtext]'将括号中的文本保存到变量.当然它不起作用,但我正在寻找类似于此的方法.在这样的正则表达式中包含变量会非常优雅.我能做什么最好的？

谢谢!

我想构建一个将列表拆分为两个的函数:一个列表包含原始列表中满足某个谓词的元素,另一个列表包含所有不满足某个谓词的元素.以下是我的尝试:

fn split_filter<T: Clone + Sized>(a: &Vec<T>, f: Fn(&T) -> bool) -> (Vec<T>, Vec<T>) {
    let i: Vec<T> = vec![];
    let e: Vec<T> = vec![];
    for u in a.iter().cloned() {
        if f(&u) {
            i.push(u)
        } else {
            e.push(u)
        }
    }

    return (i, e);
}

fn main() {
    let v = vec![10, 40, 30, 20, 60, 50];
    println!("{:?}", split_filter(&v, |&a| a % 3 == 0));
}

但是,我收到两个错误:

error[E0277]: the trait bound `for<'r> std::ops::Fn(&'r T) -> bool + 'static: std::marker::Sized` is not …

对于我的一个应用程序,必须经常调用以下函数.这个功能占用了大量的CPU,因此我想知道你是否知道如何提高性能.

代码计算四个字符组合的出现次数.在测试期间,我发现地图中的条目数大约为100. 文本的长度在100到800的范围内.初始大小200是猜测,代码似乎运行得比没有指定初始值更快尺寸.但它可能不是最佳值.

private Map<String, Integer> getTetagramCount(final String text) {
    final Map<String, Integer> cipherTetagrams = new HashMap<String, Integer>(200);

    for (int i = 0; i < text.length() - 4; i++) {
        final String tet = text.substring(i, i + 4);

        final Integer count = cipherTetagrams.get(tet);
        if (count != null) {
            cipherTetagrams.put(tet, count + 1);
        } else {
            cipherTetagrams.put(tet, 1);
        }
    }

    return cipherTetagrams;
}

对于大图中的每个点,我试图创建一个列表,其中包含距离n起始节点一定距离的未访问节点的数量.示例输出是: [1,3,6] 这意味着在距离0处有起始节点本身,在距离1处有3个新的(未探测的)节点等.

如果你只有一个起点,这很容易:你只需在广度优先搜索的基础上增加一个shell计数器.当我必须为图中的每个节点执行此操作时,问题就开始了.因为我的图形很大(> 100000个节点),所以对每个点执行上述例程变得相当慢.

我首次尝试优化这个是检查节点上的列表a是否可以从所有邻居的列表构建a,但到目前为止我没有运气,部分原因是图中的周期.我希望你们中的一些人可能有一些不错的想法,也许还有一些我可以缓存的额外信息.

我的问题:如果您知道必须为每个节点执行此操作,是否有一种优化此类搜索的方法？

我正在尝试为 sublime text 3 自定义折叠，即标记：

*--#[
    some stuff
*--#]

指出我的地区。我试过AAAPacakgeDev，但它似乎不支持折叠。该包SyntaxFold引入了自己的逻辑和新的键绑定，这似乎是不必要的。

它似乎.tmLanguage确实支持折叠，所以我所做的是Obective-C.tmLanguage从它的包中复制Packages\FORM并重命名为“FORM.tmLanguage”。然后我将标记修改为：

<key>foldingStartMarker</key>
<string>^\*..#\[.*$</string>
<key>foldingStopMarker</key>
<string>^\*..#\].*$</string>

并将语法更改为 FORM。即使当我对代码执行正则表达式时颜色发生变化并且模式匹配，折叠也不起作用。

我究竟做错了什么？

我有一个 tokio 核心，其主要任务是运行 websocket（客户端）。当我从服务器收到一些消息时，我想执行一个新任务来更新一些数据。下面是一个最小的失败示例：

use tokio_core::reactor::{Core, Handle};
use futures::future::Future;
use futures::future;

struct Client {
    handle: Handle,
    data: usize,
}

impl Client {
    fn update_data(&mut self) {
        // spawn a new task that updates the data
        self.handle.spawn(future::ok(()).and_then(|x| {
            self.data += 1; // error here
            future::ok(())
        }));
    }
}

fn main() {
    let mut runtime = Core::new().unwrap();

    let mut client = Client {
        handle: runtime.handle(),
        data: 0,
    };

    let task = future::ok::<(), ()>(()).and_then(|_| {
        // under some conditions (omitted), we update the …

我正在使用C库Cuba，该库使用从C中创建的多个线程调用的回调函数。Cuba并行化基于fork/ waitPOSIX函数而不是pthreads（arxiv.org/abs/1408.6373）。它在core参数中给出当前线程。

我正在尝试将此回调函数的结果记录到屏幕和文件中。如果我使用println!，则会得到预期的输出，但是如果slog使用Mutex漏极，则输出会被扭曲。如果使用async漏极，则根本没有输出。

Mutex因为无法看到该函数实际上是从另一个线程调用的，所以不锁定吗？我试图用Rust线程重新创建问题，但是不能。最好是我想花async些功夫。

下面是提供有问题的行为的示例程序。回调获取vegas函数的最后一个参数作为其参数之一。这是记录器克隆的向量。这样，每个内核都应拥有自己的记录器副本：

#[macro_use]
extern crate slog;
extern crate cuba;
extern crate slog_term;

use slog::Drain;

// this function is called from different c threads
// `core` indicates which thread
fn integrand(
    _x: &[f64],
    _f: &mut [f64],
    loggers: &mut Vec<slog::Logger>,
    _nvec: usize,
    core: i32,
) -> Result<(), &'static str> {
    info!(loggers[core as usize], "A\nB\nC");

    Ok(())
}

fn main() { …

我试图在Rust中创建一个不相交的集合结构。看起来像这样

struct DisjointSet<'s> {
    id: usize,
    parent: &'s mut DisjointSet<'s>,
}

默认的不交集集是单例结构，其中父级引用自身。因此，我想选择执行以下操作：

let a: DisjointSet = DisjointSet {
    id: id,
    parent: self,
};

其中self是对将要创建的对象的引用。

我尝试通过创建自定义构造函数来解决此问题。但是，我的尝试失败了，因为不允许部分初始化。编译器建议使用Option<DisjointSet<'s>>，但这非常难看。你有什么建议吗？

我的问题不同于包含彼此认识的字段的结构， 因为我有兴趣获取对将要创建的结构的引用。

我有两个HashMaps,并希望在某些条件下交换它们之间的值.如果第二个密钥不存在HashMap,则应插入密钥.我不想克隆该值,因为这太贵了.

(简化的)关键代码不起作用如下:

match hm1.get_mut(&1) {
    Some(ref mut x) => match hm.entry(1) {
        Entry::Occupied(mut y) => if y.get().replace {
            mem::swap(x, &mut y.get_mut());
        },
        Entry::Vacant(y) => {
            y.insert(mem::replace(x, dummy));
        }
    },
    None => {}
}

(在Rust Playground)

我收到错误:

error[E0597]: `y` does not live long enough
  --> src/main.rs:28:9
   |
23 |                 mem::swap(x, &mut y.get_mut());
   |                                   - borrow occurs here
...
28 |         },
   |         ^ `y` dropped here while still borrowed
29 |         None => {}
30 …

在onCreate()方法中,我加载了一个级别列表.它存储在单例结构中(使用枚举).当我按下后退按钮并再次返回时,列表仍然存在,并再次添加所有级别.我不明白为什么会发生这种情况,因为Activity Lifecycle声明该进程在再次调用onCreate()之前被终止.

为什么会这样？

编辑,一些代码:

在单独的文件中:

public enum GameInformation {
   INSTANCE;
       public List<Level> levelSet;

       public void loadLevelSet(Context context) {
       ...
       }
}

在主要活动中:

public void onCreate(Bundle savedInstanceState) {
    GameInformation.INSTANCE.loadLevelSet(this);
}