小编ide*_*n42的帖子

在Rust中,我开始编写迭代器,从带有回调函数的代码转换它们.

我遇到的问题是,在函数的多个分支中使用回调的代码没有如此干净地转换为Rust迭代器.

给出一些伪代码.

// function using callbacks where the caller can exit at any time,
// can be used in a similar way to an iterator.
fn do_stuff(args, callback_fn(cb_args)) {
    // define a, b, c... args
    if callback_fn(a, b, 0) == false { return; }
    for i in 0..n {
        if callback_fn(c, d, i) == false { return; }
    }
    if callback_fn(e, f, -1) == false { return; }
}

将它转换为迭代器是相当尴尬的,因为我需要存储一些代表每个分支的状态.

impl Iterator for MyStruct {
    fn next(&mut self) -> …

我想在文件中对类似的函数进行分组,但是这些函数需要返回一个不公开的类型:

struct MyStruct;

mod my_mod {
    use super::MyStruct;

    // There are other, similar functions that also return `MyStruct`
    pub fn foo() -> MyStruct {
        MyStruct
    }
}

fn main() {
    let _var = my_mod::foo();
}

这失败了,错误MyStruct.

通常,不允许公共函数在其签名中具有私有类型是有意义的.但是,在此特定情况下,结构可在模块根级别获得.

有没有办法在不MyStruct公开的情况下支持这个？

Rust是否有办法声明一个函数,不使用它的结果会警告 - 对于任何类型？

像GCC那样的东西__attribute__((warn_unused_result));？

使用哈希映射时,key:value如果密钥尚不存在,则通常需要添加一对.

这读得不错,但不是最佳.

if !map.contains(key) {
    let val = create_val();
    map.insert(key, val);
    some_creation_logic(val);
} else {
    let val = map[key];
    some_update_logic(val);
}

虽然这可行,但它总是会进行2次查找.

我最接近的是使用Entry.or_insert(或or_insert_with),计算长度,以便else可以采取分支.

let map_len_prev = map.len();
let val = map.or_insert_with(key, create_val);
if map_len_prev != map.len() {
    some_creation_logic(val);
} else {
    some_update_logic(val);
}

是否有更清晰的方法在需要时插入一个值,同时保持一种运行两个逻辑分支的方式来处理/不存在的情况？

鉴于这个在子目录中使用本地包的小型库,我如何使其中一个依赖项可选,具体取决于是否启用了某个功能？

[package]
name = "image_load"
description = "Small wrapper for image reading API's."
version = "0.1.0"

[features]

default = ["use_png"]

[dependencies]

[dependencies.image_load_ppm]
path = "ppm"

# How to make this build _only_ when 'use_png' feature is enabled?
[dependencies.image_load_png]
path = "png"

在阅读文档时,这将显示如何使用可选的外部依赖项.在上面的示例中,我使用的是一个本地子目录,我想要构建或不构建 - 基于一个功能.

如何image_load_png在use_png启用该功能时仅进行构建.

鉴于一个特征,我们可能希望为许多类型实现它.

pub trait RTypeUnit {
    fn zero() -> Self;
    fn one() -> Self;
}

impl RTypeUnit for usize { fn zero() -> usize { 0 } fn one() -> usize { 1 } }
impl RTypeUnit for isize { fn zero() -> isize { 0 } fn one() -> isize { 1 } }
impl RTypeUnit for u64 { fn zero() -> u64 { 0 } fn one() -> u64 { 1 } }
impl RTypeUnit for i64 { fn …

Rust 允许一种 do-while 循环，例如：

所以C风格：

do {
    something();
} while (test());

可以用 Rust 写成：

while {
    something();
    test()
}{}

但是在这种情况下使用 break 会出现问题：

所以这个C风格：

do {
    if (something()) {
        break;
    }
} while (test());

不能用 Rust 写成：

while {
    if (something()) {
        break;
    }
    test()
}{}

编译失败cannot break outside of a loop。

有没有办法摆脱这种形式的while循环？

注 1)使用的原因：在这种情况下将在最初进入循环时使用
do {...} while test()流控制而不是。
while test() {...}test()false

注2）使用 while {...}流程控制时：continue在代码体中调用将跳过最后的break检查。

请参阅相关问题：如何在宏中包装 do-while 样式循环，保持“继续”流程控制？

Bresenham 的画线算法是众所周知的，而且很容易实现。

虽然有更高级的方法来绘制抗锯齿线，但我有兴趣编写一个基于浮点坐标绘制单个像素宽度的非抗锯齿线的函数。

这意味着虽然第一个和最后一个像素将保持不变，但它们之间绘制的像素将根据两个端点的子像素位置产生偏差。

原则上这不应该那么复杂，因为我假设可以使用子像素偏移来计算error绘制线条时使用的初始值，并且算法的所有其他部分保持不变。

无子像素偏移：

X###
    ###X

假设右手点有一个靠近顶部的子像素位置，这条线可能如下所示：

以子像素偏移为例：

X######
       X

是否有一种经过验证的真实方法来绘制考虑亚像素坐标的线条？

笔记：

• 这似乎是一个常见的操作，我已经看到 OpenGL 驱动程序考虑到这一点，例如 - 使用GL_LINE，但从快速搜索中我没有在网上找到任何答案 - 可能使用了错误的搜索词？
• 乍一看，这个问题看起来可能是以下内容的重复：
  精确的子像素线绘制算法（光栅化算法）
  但是，这是询问绘制宽线，这是询问偏移单个像素线。
• 如果没有一些标准方法，我会尝试将其写下来作为答案发布。

给定一个带有一些未键入值的简单枚举,可能希望此枚举的大小使用较小的整数类型,然后使用默认值.例如,这提供了将枚举存储在数组中的能力u8.

enum MyEnum { 
    A = 0,
    B,
    C,
}

可以使用u8数组并将它们与某些常量进行比较,但我希望使用枚举来确保在匹配语句中处理所有可能性.

如何指定它以size_of匹配所需的整数类型？

可以Self在一个impl块内使用:

impl SomeStruct {
    pub fn new() -> Self {
        SomeStruct { foo: 1, bar: 1, }
    }
}

有没有办法在函数体中引用类型？例如:

impl SomeStruct {
    pub fn new() -> Self {
        Self { foo: 1, bar: 1, }
    //  ^^^^ not recognized, possibly there is some alternative?
    }
}

这不是必需的,只能在可以推断时避免重复长结构名称.它也可能对生成的代码很有用.