小编lef*_*ead的帖子

我有一个lib用ES6编写的node.js库(用Babel编译),我在其中导出以下子模块:

"use strict";

import * as _config from './config';
import * as _db from './db';
import * as _storage from './storage';

export var config = _config;
export var db = _db;
export var storage = _storage;

如果从我的主项目中我包含这样的库

import * as lib from 'lib';
console.log(lib);

我可以看到正确的输出,它按预期工作{ config: ... }.但是,如果我尝试像这样包含库:

import lib from 'lib';
console.log(lib);

它会undefined.

有人能解释一下这里发生了什么吗？这两种导入方法不应该是等价的吗？如果没有,我错过了什么区别？

假设我有一个 enum E，它可能是自动生成的或不受我控制的，有许多变体，每个变体都有许多字段。

enum E {
    A {
        x1: u8,
        x2: u8,
        x3: u8,
        // ...
        x9: u8,
    },
    B,
}

实际上，这些字段可能更长，既不便于记忆，也不便于打字。

我现在想编写对 (variants of) 进行操作的函数E。但是，我也很懒惰，我不想重复自己，在解构 enum* 时显式声明每个使用的字段。

直觉上，我希望绑定运算符@在这里完成这项工作，但它只绑定整个 enum e，而不是给定的 variant E::A。

实现以下意图的最短/最优雅的方法是什么？

fn f(e: &E) {
    match e {
        bad @ E::A { .. } => dbg!(bad.x1),
        _ => {}
    }
}

*更新，因为这已经被带到了两个答案了，我也没有想匹配E::A { x1, .. }，因为这需要具有长名称的多个字段时变得乏味。在下面的示例中，我必须some_other_field_with_an_impossibly_long_name在自己的代码中输入两次（一次是在绑定时，一次是在使用时），而在假设的bad @ E::A …

假设我创建或拥有node.js库 lib.js

export class C {
    constructor(value, callback) {
        callback(false, `Hello ${value}`);
    }

    task(value, callback) {
        callback(false, "returned " + value);
    }
}

重要的是,类的构造函数需要接受回调,因为它执行数据库连接和文件I/O. 如果我现在导入并使用库回调式,一切都很好(见c1下文).

我真的想宣传我使用它的库,使对象构造更方便(实际上它是一大堆类和方法).

但是,我无法new在一个承诺安全的地方找到适当的方法.

import Promise from 'bluebird';
import * as lib from './lib';


Promise.promisifyAll(lib);


// old style -- works as expected
const c1 = new lib.C("c1", (e, v) => {
    console.log(c1, e, v); 
});


// assuming c1 got initialized, .task() also works
c1.task("t1", console.log);
c1.taskAsync("t2").then(() => console.log("also works"));


// But …

使用Angular 2,典型的堆栈跟踪如下所示(参见附图)

不幸的是,这些行似乎都与我的代码无关(使用Typescript和大量的async/await).如何才能获得引发错误的真实堆栈跟踪/行？

(是的,我在控制台上也获得了很多"原始堆栈跟踪"消息,但它们同样没用.

背景

我有一种情况,我想抽象两种不同的操作模式Sparse和Dense.我选择哪一个是编译时决定.

与这些模式正交我有很多Kernels.内核的实现细节和签名在两种模式之间不同,但每种模式具有相同的内核.内核将在运行时根据模型文件确定.

我现在想创建一个BlackBox处理模式和内核的方法.

简化代码

我删除了其他内核和稀疏模式.

pub struct XKernel;

pub trait KernelDense {
    fn compute_dense(&self, vectors: &[f32]);
}

impl KernelDense for XKernel {
    fn compute_dense(&self, vectors: &[f32]) {}
}

pub trait KernelCompute<V> {
    fn just_compute_it(&self, vectors: &[V]);
}

impl KernelCompute<f32> for (dyn KernelDense + 'static) {
    fn just_compute_it(&self, v: &[f32]) {
        self.compute_dense(v);
    }
}

pub trait Generalization {
    type V: 'static;

    type OperatorType: KernelCompute<Self::V>;

    fn set_kernel(&self, x: Box<Self::OperatorType>);

    fn compute(&self, v: &[Self::V]); …

当我尝试编译这段代码时：

impl<S, V> Storage for Database<S>
where
    S: StoredElement,
    V: VisibleElement,

编译器抱怨

impl<S, V> Storage for Database<S>
where
    S: StoredElement,
    V: VisibleElement,

我假设V: VisibleElement是一个谓词，但显然编译器不同意。

那么，在 Rust 中，谓词到底是什么？

在下面的示例（Typescript，1.7 +）中，我将需要更改什么以允许B.callback具有与签名不同的签名A.callback？

class A {
    callback(result: number) {
    }
}


class B extends A {
    callback(result: number, option: number) {
    }
}

目前，这给 test.ts(7,7): error TS2415: Class 'B' incorrectly extends base class 'A'.

在现实世界中，我的示例更加复杂，但是我可以（基于某种配置）动态地（或多或少）保证所请求的参数在那里。

我需要执行一个FFI签名：

pub unsafe extern fn f(header_size: u32, header_ptr: *mut u8) -> i32;

FFI调用程序应提供一个缓冲区header_ptr以及该缓冲区的大小header_size。预期Rust会将一个字符串填充到该缓冲区中，直到header_size，0如果成功，则返回。FFI调用程序应将字符串解释为ASCII。

给定headers: &str我要提供的内容，如何以最惯用的方式填充该缓冲区？

现在我有：

let header_bytes = slice::from_raw_parts_mut(header_ptr, header_size as usize);

if header_bytes.len() < headers.len() { return Errors::IndexOutOfBounds as i32; }

for (i, byte) in headers.as_bytes().iter().enumerate() {
    header_bytes[i] = *byte;
}

但这感觉不对。

编辑，我认为这是不完全相同的副本来这个，因为我的问题涉及到字符串，STR转换和对CStrings时IIRC有特殊的考虑。

我试图在Typescript 1.5-beta中使用shelljs(通过DefinitelyTyped).在我的代码中,我想使用exec具有以下签名的函数:

export function exec(command: string, options: ExecOptions): ExecOutputReturnValue | child.ChildProcess;

export interface ExecOutputReturnValue
{
    code: number;
    output: string;
}

如果我导入并使用库如下(在正常的ES6 JavaScript中工作完全正常)

import * as $ from 'shelljs';
const code =  $.exec(command, { silent: true }).code;

Typescript编译器给了我error TS2339: Property 'code' does not exist on type 'ChildProcess | ExecOutputReturnValue'.

如何以类型安全的方式访问.code？

我正在努力解决对象安全的基础问题.如果我有这个代码

struct S {
    x: i32
}

trait Trait: Sized {
    fn f(&self) -> i32 where Self: Sized;
}

fn object_safety_dynamic(x: Trait) {}

我收到

fn object_safety_dynamic(x: Trait) {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `traits::Trait` cannot be made into an object
= note: the trait cannot require that `Self : Sized`

当添加/更改:Sized为特征的继承或f绑定时,我收到稍微不同的错误消息.

有人能解释一下:

• 为什么这个特定的例子不起作用？Trait Objects一章说明"那么什么使方法对象安全？每种方法都必须要求Self: Sized".那不是满满的吗？

• Trait: Sized和之间有什么区别where Self: Sized？(嗯,是的,一个继承了特性,另一个是参数绑定,但是从Rust的特质对象的角度来看？

• 我必须做的首选改变是什么object_safety_dynamic？

rustc 1.19.0-nightly (01951a61a 2017-05-20) …

如果我有这个代码：

trait Trait {
    fn f(&self) -> i32 where Self: Sized;

    fn g(&self) -> i32;
}


fn object_safety_dynamic(x: &Trait) {
    x.f();    // error 
    x.g();    // works
}

该条款实际上有什么where作用？

天真地，我在想where Self: Sized;关于类型实现的一些规定Trait，比如“如果你实现Trait类型，A你的类型A必须调整大小，即，它可以i32但不能[i32]”。

然而，这样的约束宁愿作为trait Trait: Sized（如果我错了请纠正我）？

现在我注意到where Self: Sized;实际上决定了我是否可以从内部调用f或。gobject_safety_dynamic

我的问题：

1. 幕后发生了什么？

2. 我实际上是在告诉编译器什么（用简单的英语）where Self: Sized;使g()工作有效但f()无效？

3. 特别是：由于无论如何都是一个参考，因此各种（大小或未大小）类型之间&self存在编译差异。无论类型是否调整大小，它是否总是会归结为类似的东西？fg_vtable_f_or_g(*self) -> i32 …

在我的 Angular 2 / Bootstrap / AdminLTE 中，我有以下模板：

<button type="button" class="btn btn-default"><i class="fa fa-cutlery" (click)='munch(1);'></i></button>

这是调用这个方法：

async munch(amount: number) {
    console.log("Start")
    await this.food.redeem(amount);
    console.log("Stop")
}

该按钮嵌入在导航栏中。然后我按下它，它似乎有大约 2/3 的随机机会触发。但是，在大约 1/3 的所有情况下，什么都没有发生，我什Start至在控制台上都看不到。

有什么可能会干扰 Angular 2 触发这些点击事件的方式吗？我的页面相对简单，我很确定我自己没有搞乱任何低级 DOM/事件处理/JavaScript。