小编Jos*_*ica的帖子

根据Haskell维基,scanl1功能是部分的.不过,我不明白输入结果是什么.对于列表函数,我习惯于问题输入是空列表(如for head)或无限列表(如for reverse).但是,scanl1似乎正确处理这两种类型的列表.这实际上是部分功能吗？如果是这样,那么输入的一个例子是什么？

我正在尝试构建一个 Haskell 函数，它与 Prelude 的product. 然而，与该函数不同的是，它应该具有以下两个属性：

1. 它应该在常量空间中运行（忽略某些数字类型Integer不是这样的事实）。例如，我想myProduct (replicate 100000000 1)最终返回 1，与 Prelude 不同product，它用完我所有的 RAM 然后给出*** Exception: stack overflow.
2. 它应该在遇到 0 时短路。例如，我想myProduct (0:undefined)返回 0，与 Prelude 的不同product，它给出*** Exception: Prelude.undefined.

到目前为止，这是我想出的：

myProduct :: (Eq n, Num n) => [n] -> n
myProduct = go 1
  where go acc (x:xs) = if x == 0 then 0 else acc `seq` go (acc * x) xs
        go acc [] …

我有以下C程序：

#include <stdio.h>
#include <unistd.h>

void readAndEchoAll(void) {
    for(;;) {
        char buf[100];
        ssize_t size = read(STDIN_FILENO, buf, sizeof(buf));
        if(size <= 0) {
            return;
        }
        fwrite(buf, 1, size, stdout);
    }
}

int main(void) {
    puts("Reading and echoing STDIN until first EOF...");
    readAndEchoAll();
    puts("Got first EOF. Now reading and echoing STDIN until second EOF...");
    readAndEchoAll();
    puts("Got second EOF.");
    return 0;
}

当我运行它时，它会按照我想要的方式工作。这是它的作用：

Reading and echoing STDIN until first EOF...
asdf
^Dasdf
Got first EOF. Now reading and echoing STDIN until second EOF... …

假设我们有一些数据类

{-# LANGUAGE DeriveGeneric, DuplicateRecordFields #-}

import Data.Aeson
import Data.ByteString.Lazy.Char8
import GHC.Generics

data Foo a = Foo { payload :: a }
    deriving (Show, Generic)

instance ToJSON a => ToJSON (Foo a)
instance FromJSON a => FromJSON (Foo a)

data Bar a = Bar { payload :: Maybe a }
    deriving (Show, Generic)

instance ToJSON a => ToJSON (Bar a)
instance FromJSON a => FromJSON (Bar a)

然后我们尝试解码如下：

*Main > decode $ pack "{}" :: Maybe (Bar String)
Just (Foo …

是否可以在 python 会话中导入 sagemath 函数？

从用户的角度来看，我希望做的是：

>>> import sage
>>> sage.kronecker_symbol(3,5)  # ...or any other sage root functions

而不是kronecker_symbol(3,5)从 sagemath 会话访问。如果可能的话，它会非常方便，因为可以将 sagemath 的所有功能嵌入到 Python 世界中。

我最近才开始使用cppyyand ctypes，所以这可能是一个有点愚蠢的问题。我有以下 C++ 函数：

float method(const char* args[]) {
    ...
}

从 Python 我想args作为字符串列表传递，即：

args = *magic*
x = cppyy.gbl.method(args)

我以前发现过这个，所以我使用了

def setParameters(strParamList):
    numParams    = len(strParamList)
    strArrayType = ct.c_char_p * numParams
    strArray     = strArrayType()
    for i, param in enumerate(strParamList):
        strArray[i] = param
    lib.SetParams(numParams, strArray)

来自 Python：

args = setParameters([b'hello', b'world'])

c_types.c_char_p需要一个字节数组。但是，当x = cppyy.gbl.method(args)我打电话时，我得到

TypeError: could not convert argument 1 (could not convert argument to buffer or nullptr)

我不完全确定为什么这会是错误的，因为argsis …

Intel CET（控制流执行技术）由两部分组成：SS（影子堆栈）和 IBT（间接分支跟踪）。如果您需要间接地转移到地方，你不能把一个endbr64由于某种原因，你可以抑制IBT单个jmp或call指令用notrack。是否有等效的方法来抑制单个ret指令的SS ？

对于上下文，我正在考虑这将如何与 retpolines 交互，其关键控制流程或多或少类似于push real_target; call retpoline; pop junk; ret. 如果没有办法为此抑制 SS ret，那么在启用 CET 时是否有其他方法让 retpolines 工作？如果没有，我们将有哪些选择？我们是否需要为所有内容维护两组二进制包，一组用于需要 retpolines 的旧 CPU，另一组用于支持 CET 的新 CPU？如果英特尔被证明是错误的，而我们最终仍然需要在他们的新 CPU 上使用 retpolines 呢？我们是否必须放弃 CET 才能使用它们？

可以使用的一种可能的文件类型stat(2)是S_IFWHT，也称为 whiteout。它是什么？

考虑使用这些不同的解析器组合器。

import Control.Applicative.Combinators
import Text.Regex.Applicative
 
main :: IO ()
main = do
  let parser1 = sym '"' *> manyTill anySym (sym '"')
  print $ match parser1 "\"abc\""
  let parser2 = sym '"' *> many anySym <* sym '"'
  print $ match parser2 "\"abc\""

import Control.Applicative.Combinators            
import Text.ParserCombinators.ReadP hiding(many, manyTill)
 
main :: IO ()
main = do
  let parser1 = char '"' *> manyTill get (char '"')
  print $ readP_to_S parser1 "\"abc\""
  let parser2 = char '"' *> many get <* …

Qt定义Q_DISABLE_COPY如下：

#define Q_DISABLE_COPY(Class) \
    Class(const Class &) = delete;\
    Class &operator=(const Class &) = delete;

Q_DISABLE_COPY是在使用QObject类，但它的文件说，它应该在其所有的子类可以作为很好：

当你创建自己的子类的QObject（董事或间接的），你应该不给它一个拷贝构造函数或赋值操作符。然而，简单地从类中省略它们可能还不够，因为如果您错误地编写了一些需要复制构造函数或赋值运算符的代码（这很容易做到），您的编译器会为您精心创建。你必须做得更多。

但是考虑这个程序：

struct Base {
    Base() = default;

private:
    Base(const Base &) = delete;
    Base &operator=(const Base &) = delete;
};

struct Derived : Base {};

int main() {
    Derived d1;
    Derived d2(d1); // error: call to implicitly-deleted copy constructor of 'Derived'
    Derived d3;
    d3 = d1; // error: object …