我有一个类方法,它接受一个参数作为字符串,并返回一个具有匹配type属性的对象.此方法用于缩小区分的联合类型,并保证返回的对象始终是具有所提供的type区别值的特定缩小类型.

我正在尝试为这种方法提供一个类型签名,它将正确地缩小从一般参数的类型,但我没有尝试从被区分的联合中缩小它,而没有用户明确提供它应该缩小到的类型.这有效,但很烦人,感觉很多余.

希望这种最小的再现清楚地表明:

interface Action {
  type: string;
}

interface ExampleAction extends Action {
  type: 'Example';
  example: true;
}

interface AnotherAction extends Action {
  type: 'Another';
  another: true;
}

type MyActions = ExampleAction | AnotherAction;

declare class Example<T extends Action> {
  // THIS IS THE METHOD IN QUESTION
  doSomething<R extends T>(key: R['type']): R;
}

const items = new Example<MyActions>();

// result is guaranteed to be an ExampleAction
// but it is not inferred as such
const …

在redux-observable是否可以使用isomporphic-fetch而不是Rx.DOM.ajax？

上下文

我正在为需要大量运行时函数的语言编写编译器.我正在使用LLVM作为我的后端,因此codegen需要所有运行时类型(函数,结构等)的类型,而不是使用LLVM API手动定义所有这些类型或手写LLVM IR我想编写C中的头文件并编译为编译器可以引入的bitcode LLVMParseBitcodeInContext2.

问题

我遇到的问题是clang似乎没有保留任何任何函数定义都没有使用的类型声明.铛具有其听起来像它应该解决这个问题,但不幸的是,不是和谷歌搜索表明它名不副实,因为它不仅影响未使用的定义,而不是声明.-femit-all-decls

然后我想也许如果我只将头.gch文件编译成文件我可以用LLVMParseBitcodeInContext2相同的方式将它们拉入(因为文档说它们使用"相同的"bitcode格式",但是这样做的错误error: Invalid bitcode signature必须有所不同.也许差别小到可以解决？

任何可以为复杂运行时自动化的建议或相对简单的解决方法？如果有人对接近这个一般用例有一个完全替代的建议,我也会感兴趣,记住我不想在运行时函数体中静态链接我生成的每个单个目标文件,只是类型.我想这也是其他编译器所需要的,所以如果我接近这个错误,我不会感到惊讶.

例如,给出这个输入:

runtime.h

struct Foo {
  int a;
  int b;
};

struct Foo * something_with_foo(struct Foo *foo);

我需要一个具有此等效IR的bitcode文件

runtime.ll

; ...etc...

%struct.Foo = type { i32, i32 }

declare %struct.Foo* @something_with_foo(%struct.Foo*)

; ...etc...

我可以手动编写它,但这将是重复的,因为我还需要为其他互操作创建C头,并且理想的是不必手动保持它们同步.运行时相当大.我想我也可以做相反的事情:在LLVM IR中编写声明并生成C头.

有人问过这些年,但是对于这种大小和类型复杂性的运行时,提出的解决方案相当hacky并且相当不切实际:Clang - 将C头编译为LLVM IR/bitcode

我需要回答这个问题:给定一个依赖图中的节点,通过它们自己的传递依赖对其依赖者进行分组,这些依赖会受特定的起始节点的影响.

换句话说,给定依赖图中的节点,找到直接依赖的集合的集合,其直接依赖于从该特定起始节点导出的公共依赖.

例如,给出伪代码:

let a = 1
let b = 2
let c = a + b
let d = a + b
let e = a
let f = a + e
let g = c + d

你可以计算这个图:

如果我们用作a起始节点,我们可以看到a两者的依赖性,c并且d具有依赖性g.并且f有依赖e和a.

请注意,a根本没有任何影响b,因此在决定如何对依赖者进行分组时不应将其考虑在内a.

使用a作为起始节点,我们想要获得这些分组的依赖集:

groups = {{c, d}, {e, f}}

c并且d具有直接或传递的下游关系,并且e也 …

我似乎正在努力解决AST-> StringTemplate方面的问题,可能是因为我来自手工编写解析器 - > LLVM.

我正在寻找的是一种自动将解析规则与可以表示它的AST类匹配的方法,并且包含生成目标语言输出的方法.(在这种情况下可能使用StringTemplate.)

在伪代码中,给出了这个示例语法:

numberExpression
    : DIGIT+
    ;

我想让它映射到这个AST类:

class NumberExpressionAST extends BaseAST {
    private double value;

    public NumberExpressionAST(node) {
        this.value = node.value;
    }

    public String generateCode() {
        // However we want to generate the output.
        // Maybe use a template, maybe string literals, maybe cure cancer...whatever.
    }
}

为了交配它们,也许会有一些胶水如下:(或者你可能会疯狂的Class.forName东西)

switch (child.ruleName) {
    case 'numberExpression':
        return new NumberExpressionAST(child);
        break;
}

我一直在网上搜索,我在语法中找到了解析重写规则,->但我似乎无法弄清楚如何将所有这些逻辑排除在语法之外.特别是从模板设置和生成目标输出的代码.我可以多次走树了.

我想也许我可以使用该选项output=AST,然后可能提供我自己的从CommonTree扩展的AST类？我承认,我对ANTLR的把握非常原始,所以请原谅我的无知.我所遵循的每个教程都显示了所有这些内容与语法内联,这对我来说是完全疯狂和难以维护的.

有人能指出我一种完成类似事情的方法吗？

目标:保持AST/codegen /模板逻辑不受语法限制.

编辑---------------------------------------------

我使出通过ANTLR的实际源代码跟踪(因为他们使用自己),我看到这样类似的事情BlockAST, …

在redux-observable,史诗正在接受行动流并返回新的行动流.在我的用例中,我需要在调度某个操作后发送分析事件,之后不执行任何操作.

有了redux-saga,我可以使用takeEvery,并在saga函数内部执行副作用:

function* saga() {
  yield takeEvery('SOME_ACTION', function*() {
    sendAnalytics();
  })
}

但我怎样才能实现同样的目标redux-observable呢？有很多副作用,不需要调度新的动作,比如初始化插件,记录,设置cookie等......

如果它是这两个库的反模式,那么应该使用什么解决方案来实现这些效果呢？

根据此前的答案

你可以List.map像这样实现:

let rec map project = function
  | [] -> []
  | head :: tail ->
      project head :: map project tail ;;

但相反,它实现如下:

let rec map project = function
  | [] -> []
  | head :: tail ->
      let result = project head in
      result :: map project tail ;;

他们说这是以这种方式完成的,以确保在预期的顺序中调用投影函数,以防它有副作用,例如

map print_int [1;2;3] ;;

应该打印123,但第一个实现将打印321.但是,当我在OCaml和F#中自己测试它们时,它们会产生完全相同的123结果.

(请注意,我在OCaml和F#REPL中对此进行测试 - 评论中的Nick表示这可能是我无法重现的原因,但为什么？)

我有什么误会？有人可以详细说明为什么他们应该产生不同的订单以及我如何重现？这与我之前对过去编写的OCaml代码的理解相反,所以这对我来说很惊讶,我想确保不要重复这个错误.当我读到这两个时,我把它读作完全相同的东西与一个无关的中间绑定.

我唯一的猜测是使用cons的表达式评估顺序是从右到左,但这看起来很奇怪？

这纯粹是为了更好地理解OCaml如何执行代码的研究,我真的不需要List.map为生产代码创建自己的代码.

在OCaml中,功能应用的评估顺序未指定(也称为非确定性).

在标准ML中,它是否也是非确定性的或确定性的？您能否提供澄清的规格部分的参考？

编辑:对于你后来的人,我也学到了像SML一样,在F#中指定顺序和确定性 - 与OCaml不同,考虑到两者在语法上的接近程度,这更加疯狂.如果你在他们之间切换很容易忘记.

我有一个动作然后会触发ajax请求.

如果由于某种原因动作失败,我想什么都不做.而不是创建只返回先前状态的空白操作,是否可以执行无操作功能？

export default function fetchMeetups(action$) {
  return action$.ofType(statusActions.START_APP)
    .mergeMap(action =>
      ajax.getJSON(`${config.API_BASE_URL}/api/v1/meetups`)
      .map(meetups => calendarActions.meetupsReceived(meetups))
    )
    .catch(error => Observable.noop())
};

我已经从上次应用程序打开时保存了会面(使用redux-persist),所以如果api请求失败,我只是希望它什么都不做.

这可能吗？

我从Rxjs找到了这个,但我不知道如何使用它:https://xgrommx.github.io/rx-book/content/helpers/noop.html

我正在尝试在 WebAssembly 中运行的自定义语言中使用wee_alloc。但是，我需要完全理解它如何知道从哪里开始堆，以便我的堆栈和静态分配不会破坏它，反之亦然。

我的理解是 malloc 等。知道从哪里开始堆取决于平台，通常只是一个约定，或者在某些情况下不适用。然而，在 WebAssembly 中，我们只能拥有一块连续的线性内存，因此我们必须共享它并且需要使用约定。

通过阅读代码，wee_alloc 所做的似乎是假设我们开始使用的任何内存都是完全禁止的，而是使用该grow_memory指令创建堆所需的第一块内存。这实际上意味着堆开始的索引/地址是初始大小的最高索引加一。（编辑：它实际上不是 + 1，我忘了索引是从零开始的；一对一错误？？）

例如，如果我们从 1 页的初始内存大小开始：

 current_memory = 1 page = 64KiB = 65,536 bytes

然后堆从索引 65537 开始。

我的理解正确吗？

我有一个问题，我不知道如何解决。

我有两个史诗，可以请求api和更新商店：

const mapSuccess = actionType => response => ({
  type: actionType + SUCCESS,
  payload: response.response,
});

const mapFailure = actionType => error => Observable.of({
  type: actionType + FAILURE,
  error,
});

const characterEpic = (action$, store) =>
  action$.ofType(GET_CHARACTER)
    .mergeMap(({ id }) => {
      return ajax(api.fetchCharacter(id))
        .map(mapSuccess(GET_CHARACTER))
        .catch(mapFailure(GET_CHARACTER));
    });

const planetsEpic = (action$, store) =>
  action$.ofType(GET_PLANET)
    .mergeMap(({ id }) => {
      return ajax(api.fetchPlanet(id))
        .map(mapSuccess(GET_PLANET))
        .catch(mapFailure(GET_PLANET));
    });

现在，我有一个简单的场景，在该场景中，我想创建结合了以上两者的第三个动作，我们称之为fetchCharacterAndPlanetEpic。我该怎么做？我认为在很多情况下（对我而言），重要的是在第二个操作开始之前将第一个操作的结果发送到商店。这与Promises和可能是微不足道的redux-thunk，但是我无法以某种方式想出rxjs和and 一起实现的方法redux-observable。

谢谢！

例如这段代码jsbin的例子

const pingEpic = action$ =>
  action$.ofType(PING)
    .delay(1000) // Asynchronously wait 1000ms then continue
    .mapTo({ type: PONG })
    .takeUntil(action$.ofType(CANCEL));

单击取消按钮后,如果操作为"takeUntil",则表示无效.为什么取消后,延迟1秒钟,并且不再发生变化.

问题很简单，如何将Redux-observable与EventSource一起使用？

使用RxJs就像：

const observable = Observable.create(observer => {
  const eventSource = new EventSource('/model-observable');
  return () => {
    eventSource.close();
  };
});

observable.subscribe({
  next: data => {
    this.zone.run(() => this.someStrings.push(data));
  },
  error: err => console.error('something wrong occurred: ' + err)
});