小编Ric*_*ast的帖子

我正在尝试编写一个Javascript项目,其中包含严格的流式输入.我也有依赖big-integer.flow-typed遗憾的是,没有预设的流量注释,Google没有提供有关该主题的任何有用信息.

像许多JavaScript包一样,big-integer导出一个通常被称为的函数bigInt.这可以直接调用,就像这样:bigInt(13),bigInt("134e134")等等,这就造成它是大的整数(我决定叫"下课"叫"的BigInteger"基于文档此功能的返回值的类型的对象- - 但我不认为内部实际上使用类,因为我相信包在ES6之前出来了).

这适用于函数的输出,我可以将方法附加到该类,我们都很好.但是,bigInt它本身有一些方法,例如bigInt.lcm(123, 234).我该如何记录这个？

declare module "big-integer-types" {
  declare class BigInteger {
    add(addend: BigIntInput): BigInteger;
    minus(subtractand: BigIntInput): BigInteger;
    /* snip */
  }
  declare type BigIntInput = number | string | BigInteger;
  declare type BigIntFn = (void | number | string | BigInteger) => BigInteger;
}

declare module "big-integer" {
  import type { BigIntFn } from "big-integer-types";
  declare export default BigIntFn
}

这非常适用于该领域 …

假设我在 Dropwizard 中有一个端点，比如说

@GET
public Response foo() { throw new NullPointerException(); }

当我到达这个端点时，它会记录异常和所有内容，这太棒了！我喜欢它。我不太喜欢的是它向用户返回一个大的状态对象status: ERROR（这很好）以及一个巨大的堆栈跟踪，我对此不太感兴趣。

显然，最好自己捕获并处理异常，但有时它们会漏掉。每次围绕整个资源编写一个 try catch 块很好，但是（a）它很麻烦，并且（b）我总是更喜欢自动化解决方案而不是“你必须记住”的解决方案。

所以我想要的是执行以下操作的东西：

1. 记录堆栈跟踪（我使用 slf4j 但我认为它适用于任何情况）
2. 返回通用错误响应，它不会暴露有关我的服务器的潜在特权信息！

我觉得必须有一种内置的方法来做到这一点——它已经以一种相对较好的方式处理异常——但搜索文档并没有发现任何东西。对此有好的解决办法吗？

假设我有一个自然数n,我想要所有素数的列表(或其他)n.

经典的主筛算法在O(n log n)时间和O(n)空间上运行- 它适用于更多命令式语言,但需要从根本上对列表和随机访问进行就地修改.

有一个涉及优先级队列的功能版本,非常漂亮 - 你可以在这里查看.这具有更好的空间复杂度O(n / log(n))(渐近更好但在实际尺度上有争议).不幸的是,时间分析是令人讨厌的,但它几乎O(n^2)(实际上,我认为它是关于O(n log(n) Li(n)),但log(n) Li(n)大约是n).

渐渐地说,使用连续的试验划分,在生成它时检查每个数字的素数实际上会更好,因为这只需要O(1)空间和O(n^{3/2})时间.有没有更好的办法？

编辑:事实证明我的计算完全不正确.文章中的算法是O(n (log n) (log log n))文章解释和证明(并参见下面的答案),而不是我上面提到的复杂的混乱.O(n log log n)如果有一个真正的算法,我仍然喜欢看到一个真正的纯粹算法.

我开始学习Rust宏,但文档有些限制.哪个好 - 我猜他们是专家.虽然我可以进行基本的代码生成,特性的实现等等,但是一些内置的宏似乎远不止于此,例如各种打印宏,它们检查字符串文字并将其用于代码扩展.

我查看了源代码print!,它调用了另一个名为的宏format_args.不幸的是,这似乎并没有构建在"纯Rust"中,评论只是说"内置编译器".

是否可以编写像print!纯Rust宏一样复杂的东西？如果是这样,它会怎么做？

我实际上对构建"编译时间"感兴趣 - 基本上将某些固定字符串识别为在编译时修复的"关键字".这可能是高性能的(可能)但主要是我只对代码生成感兴趣.

我得到一些看起来像这样的Clippy棉绒：

warning: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
  --> src/helpers/mod.rs:29:32
   |
29 |     pub fn to_vec_sorted<U, F>(self, mapper: F) -> Vec<U>
   |                                ^^^^
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#wrong_self_convention

我处理这个皮棉没有问题，我选择了它是因为它不显示任何专有代码。假设我有一个很好的理由说明为什么需要这样命名函数，并且Clippy已集成到我的CI中，所以我需要零个Clippy错误/警告。

有没有一种方法可以禁用特定行或代码块的Clippy棉绒，类似于@SuppressWarnings("whatever")Java？我觉得一定有，但是在文档中找不到任何这样做的示例。

我的数据类型如下所示：

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Matrix {
    #[serde(rename = "numColumns")]
    pub num_cols: usize,
    #[serde(rename = "numRows")]
    pub num_rows: usize,
    pub data: Vec<f64>,
}

我的 JSON 主体看起来像这样：

{
    "numRows": 2,
    "numColumns": 1,
    "data": [1.0, "NaN"]
}

这是 Jackson 提供的序列化（来自我们使用的 Java 服务器），并且是有效的 JSON。不幸的是，如果我们调用serde_json::from_str(&blob)我们会得到一个错误：

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Matrix {
    #[serde(rename = "numColumns")]
    pub num_cols: usize,
    #[serde(rename = "numRows")]
    pub num_rows: usize,
    pub data: Vec<f64>,
}

我知道浮点数有一些微妙之处，人们对事情应该如何发展有非常固执的看法。我尊重。Rust 特别喜欢固执己见，我喜欢这一点。

然而，最终这些 JSON blob 就是我将要收到的内容，我需要将该"NaN" …

我爱长生不老药流。特别是我有一个函数可以构造无限数量的质数流。您可以使用适当的Stream / Enum操作（Enum.take(10_000)或Enum.take_while(& (&1 < 1_000_000))分别）获取前10,000个或低于1,000,000的所有素数。

但是假设我事先不知道我需要多少个素数。我到了某个程度，我说，嘿，实际上还需要再加1000个素数。有没有办法说，获取流的前10,000个元素，然后以某种方式保存生成的流对象，这样我就可以按需获取（当然是重复地）下一个 1,000 个元素？

我正在尝试为Rust u32和u64数据类型实现快速素性测试.作为它的一部分,我需要计算(n*n)%d其中n和d是u32(或u64,分别地).

虽然结果很容易适合数据类型,但我对如何计算它感到茫然.据我所知,没有处理器原语.

因为u32我们可以伪造它 - 铸造u64,以便产品不会溢出,然后取模数,然后再回落u32,知道这不会溢出.但是因为我没有u128数据类型(据我所知),这个技巧不起作用u64.

因此,对u64,我能想到的最明显的方式来完成,这是莫名其妙地计算x*y得到一对(carry, product)的u64,所以我们捕获,而不是仅仅失去它(或恐慌,或其他)溢出量.

有没有办法做到这一点？还是另一种解决问题的标准方法？

我正在反序列化一些作为请求传入的 JSON 对象。输入正文是嵌套的，但某些字段有时会因各种原因而格式错误。在那种情况下我仍然想要该物体的其余部分。这并不都必须通过 serde 来完成；但现在发生的情况是，如果单个子字段被搞乱，整个请求就会被丢弃。我想以某种方式仍然反序列化该结果并将该字段标记为错误。如何才能做到这一点？

例如，数据模式可能如下所示：

struct BigNested {
    a: Vec<A>,
    b: B, // definition omitted
}

struct A {
    keep_this: Foo,
    trouble: SometimesBad,
}

trouble这是一个经常出现混乱的领域。我很乐意（例如）变成troubleaResult<SometimesBad, Whatever>并从那里处理它，但我不知道如何让 serde 让我这样做。

我刚刚开始使用Javascript和HTML5,所以我很可能犯了一些非常愚蠢的错误.事实上,我希望这就是全部,这是一个简单的解决方案.

这是我得到的输出:

(自己动手吧!)

我想要发生的只是在灰色矩形上绘制一个蓝色矩形,其中两种颜色都是他们自己的东西.我真的很困惑为什么这种混合是默认的(在我的机器上使用Chrome).

这是最小的工作示例(同样,对于我的机器):

(HTML)

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="utf-8">
        <title>Simple Canvas Game</title>
    </head>
    <body>
        <script src="js/game.js"></script>
    </body>
</html>

(javascript,这是game.js)

//set up the canvas
var canvas = document.createElement("canvas");
var ctx = canvas.getContext("2d");
canvas.width = 512;
canvas.height = 480;
document.body.appendChild(canvas);

// Draw everything
var render = function () {
    ctx.clearRect(50, 50, 100, 100);

    ctx.fillStyle = "rgb(240, 240, 240)";
    ctx.fillRect(0, 0, 100, 100);

    ctx.strokeStyle="rgb(0, 0, 255)";
    ctx.strokeRect(20,20,150,100);
}

setInterval(render, 10);

假设我们有这样的情况:我们有一个上限(这是一个float),以及一个标志"strict"(boolean).我们想要扫描值列表(浮点数)并对满足约束的每个值执行某些操作.

检查看起来像这样:

value -> strict ? (value < bound) : (value <= bound)

这不是世界末日,但bound并且strict远离该检查定义,以及代码位置的原因,将是很好不发送strict一路经历的过程.

如果可能的话,将方便地移动到"下一个值"将是方便的,这样value <= bound我们就可以检查而不是检查value < boundPlusALittleBit.

如果我们使用ints而不是floats,这很容易(boundPlusALittleBit = bound + 1)但是用浮点数做这个并不简单.是否有图书馆功能实现这一目标？

考虑以下简单示例:

pub struct Bar {
    curr: Vec<i32>,
    prev: Vec<i32>,
}

pub fn main() {
    let mut b = Bar { curr: vec![1, 2, 3], prev: vec![2, 3, 4] };

    foo(&mut b);
}

pub fn foo(bar: &mut Bar) {
    let next = vec![3, 4, 5];

    bar.prev = bar.curr;
    bar.curr = next;
}

使用Vec无所谓; 关键是Bar有两个字段没有实现Copy.这不编译:

error[E0507]: cannot move out of borrowed content
  --> derp.rs:15:16
   |
15 |     bar.prev = bar.curr;
   |                ^^^ cannot move out of …