小编dsp*_*pyz的帖子

我经常发现我想要编写两个函数f和g,但g需要多个参数.Haskell是否提供了一组操作符(我知道我可以自己编写它,但它看起来相当常见,我不想复制已经存在于Haskell中的运算符)

即类似的东西

(.@) = (.)
(.@@) f g x1 x2 = f $ g x1 x2
(.@@@) f g x1 x2 x3 = f $ g x1 x2 x3
(.@@@@) f g x1 x2 x3 x4 = f $ g x1 x2 x3 x4
...

达到一些合理数量的论点

Octave(/ matlab)用于处理多个返回值的表示法

[a, b] = f(x)

表明f(x)返回的值是一种行向量,而Octave支持向量解包(如Python的元组解包).

然而,当我说

[a, b] = [1, 2]

我明白了

错误:常量表达式的输出参数数量无效

octave是否支持vector-unpacking？

如果是这样,那么正确的符号是什么？

我在文档中找不到任何内容

通常,当我从集合中擦除元素时,我想声明它实际上已被擦除:即

assert(s.erase(e));

但是当设置NDEBUG时,元素不会被删除.但如果我写

bool removed = s.erase(e);
assert(removed);

编译器抱怨在设置NDEBUG时未使用'removed'.

我怎么能这样做？

我最后只是创建了一个实用工具方法:

inline void run_and_assert(bool b) {
    assert(b);
}

现在我可以说

run_and_assert(s.erase(e));

这有什么缺点吗？对我而言,这比luiscubal的解决方案更简单

为什么我不能从一对中返回unique_ptr？

#include <iostream>
#include <memory>
#include <utility>

using namespace std;

unique_ptr<int> get_value() {
    pair<unique_ptr<int>, int> p(unique_ptr<int>(new int(3)), 4);
    return p.first;
}

int main(void) {
    cout << *get_value() << endl;
    return 0;
}

当我尝试用g ++ 4.6编译它时,我得到:

../main.cpp: In function ‘std::unique_ptr<int> get_value()’:
../main.cpp:9:11: error: use of deleted function ‘std::unique_ptr<_Tp, _Dp>::unique_ptr(const std::unique_ptr<_Tp, _Dp>&) [with _Tp = int, _Dp = std::default_delete<int>, std::unique_ptr<_Tp, _Dp> = std::unique_ptr<int>]’
/usr/include/c++/4.6/bits/unique_ptr.h:256:7: error: declared here
make: *** [main.o] Error 1

我不明白错误信息

如何判断OCaml是否将特定函数识别为尾递归？特别是,我想知道OCaml编译器是否识别短路运算符和尾递归

感谢Jeffrey在下面的回答,我尝试了这个简单的功能

let rec check_all l =
    match l with
    | [] -> true
    | hd :: tl ->
        hd && check_all tl

事实上,它确实优化到:

camlTest__check_all_1008:
        .cfi_startproc
.L102:
        cmpl    $1, %eax
        je      .L100
        movl    (%eax), %ebx
        cmpl    $1, %ebx
        je      .L101
        movl    4(%eax), %eax
        jmp     .L102
        .align  16
.L101:
        movl    $1, %eax
        ret

如果我将Kolakoski序列定义为

kolakoski :: () -> [Int]
kolakoski () = 1 : 2 : helper ()
  where
    helper () = 2 : concat (zipWith replicate (helper ()) (cycle [1, 2]))

找到500,000,000个词

kolakoski () !! 500000000

我发现当使用ghc -O编译时,这会很快消耗大量内存.但是,如果关闭优化,它几乎不会使用任何东西.哪种优化导致了这种情况,如何将其关闭？

在 vscode 中调试我的代码时，我注意到它似乎找不到我调用的任何函数。我尝试添加到main.rs：

pub fn factorial(n: usize) -> usize {
    if n == 0 {
        1
    } else {
        n * factorial(n - 1)
    }
}

然后我在程序开始处设置一个断点并在调试控制台中键入

p factorial(5)

但我只是得到

error: could not find item。

如果我写

p crate::factorial(5)

我明白了error: could not find decl "factorial"

正确的做法是什么？我在任何地方都找不到任何例子。

我正在运行一个需要随机访问一个非常大的文件(大约151千兆字节)的程序.我发现无论何时它在Orchard实验室的某台MacPro机器上运行(详情请访问http://inst.eecs.berkeley.edu/cgi-bin/clients.cgi?choice=6a&string=),程序会尝试读取文件的特定部分并因文件系统中的错误而崩溃:

java.io.IOException: Invalid argument
    at java.io.RandomAccessFile.readBytes(Native Method)
    at java.io.RandomAccessFile.read(RandomAccessFile.java:322)

我只是使用RandomAccessFile类.

RandomAccessFile fd;
//...Initialized and already used fd with
//no problems for larger locations as well
//location == 155587178230
//numBytes == 15492560
//off == 0
//arr.length == 15492560
fd.seek(location);
fd.read(arr, off, numBytes);

无论我使用哪种Orchard实验室计算机,每次都在相同的确切字节范围内发生它.

我在运行Debian Linux的DELL计算机上测试了这段代码而没有遇到这个问题.

我收到了编译错误:

当与Fn特征族一起使用时,角括号表示法不稳定,请使用括号[E0215]

这是什么意思？我如何"使用括号"？

use std::hash::Hash;
use std::collections::HashMap;

struct MemoedFun<A, R> {
    fun: fn(&A) -> R,
    map: HashMap<A, R>,
}

fn memoize<A: Eq + Hash, R>(fun: fn(&A) -> R) -> MemoedFun<A, R> {
    MemoedFun {
        fun: fun,
        map: HashMap::new(),
    }
}

impl<'a, A, R> FnOnce<A> for &'a MemoedFun<A, R> {
    type Output=&'a R;
}

我想写这样的东西:

use std::{iter, ops};

struct Idx(usize);

fn get_inds() -> iter::Zip<iter::Map<ops::RangeFrom<usize>, fn(usize) -> Idx>, ops::RangeFrom<usize>> {
    (0..).map(Idx).zip(0..)
}

但是,这无法编译:

error: mismatched types [--explain E0308]
 --> src/main.rs:6:9
6 |>         (0..).map(Idx).zip(0..)
  |>         ^^^^^^^^^^^^^^^^^^^^^^^ expected fn pointer, found fn item
note: expected type `std::iter::Zip<std::iter::Map<std::ops::RangeFrom<usize>, fn(usize) -> Idx>, std::ops::RangeFrom<usize>>`
note:    found type `std::iter::Zip<std::iter::Map<std::ops::RangeFrom<usize>, fn(usize) -> Idx {Idx::{{constructor}}}>, std::ops::RangeFrom<_>>`

然后我施放了这个函数:

fn get_inds() -> iter::Zip<iter::Map<ops::RangeFrom<usize>, fn(usize) -> Idx>, ops::RangeFrom<usize>> {
    (0..).map(Idx as fn(usize) -> Idx).zip(0..)
}

这会生成以下编译器警告.为什么我会收到警告？使用像这样的构造函数的正确方法是什么？

warning: can't cast this type, #[warn(const_err)] on by default
 --> …