小编lef*_*out的帖子

可以使用lambda的类型作为模板参数,例如

template<typename InArg, typename Function>
class selfCompose {
  Function f;
 public:
  selfCompose(Function f): f(f) {}
  auto operator() (InArg x) -> decltype(f(f(x))) {
    return f(f(x));                              }
};

int main() {
  auto f = [](int x){return x*x;};
  std::cout << selfCompose<int, decltype(f)>(f)(4)  //  yields (4²)² = 256
            << std::endl;
  return 0;
}

但是,这种双重用途f是多余的.我们可以省略传递lambda的类型作为模板(将其转换为合适的std::function(失去多态性 - 但C++ lambdas无论如何都不是参数多态)),但是我有一个应用程序,我更喜欢不必通过它构造函数的值(因为我想将我的类的初始化本身用作模板参数,其中需要特定的构造函数签名).我喜欢它的工作方式

template<class InArg, class Function>
class selfCompose {
  Function f;
 public:
  selfCompose() {}  // default constructor for f
  auto operator() …

我正在实施一个近似计数算法,其中我们:

使用log(log n)位维护计数器X.

• 将X初始化为0

• 当物品到达时,增加X的概率(1/2)由1 ^X

• 当流结束时,输出2 ^X - 1,使E [2 ^X ] = n + 1

我的实现如下:

import System.Random

type Prob   = Double
type Tosses = Int

-- * for sake of simplicity we assume 0 <= p <= 1
tos :: Prob -> StdGen -> (Bool,StdGen)
tos p s = (q <= 100*p, s')
  where (q,s') = randomR (1,100) s

toses :: Prob -> Tosses -> StdGen -> [(Bool,StdGen)]
toses _ 0 …

在Repa包中有模板,允许以方便的方式从相邻值计算值(对卷积,图像模糊,扩散模拟等有用).

在目前的维修包中,我可以制作任何形状的模板,但只能使用二维模板mapStencil2.有没有办法将模具应用于具有不同维度的数组？甚至没有办法应用一维模板.我正在寻找一种应用三维模板的方法.

谢谢

Traversable在某种意义上,容器类的结构具有"路径"(可以对应于列表),可以在不解散结构的情况下修改其中的元素.于是

zipTrav :: Traversable t => t a -> [b] -> Maybe (t (a,b))
zipTrav = evalStateT . traverse zp
 where zp a = do
           bs <- get
           case bs of
              [] -> lift Nothing
              (b:bs') -> put bs' >> return (a,b)

但是,列表状态遍历似乎有些过时,可能不是最有效的方法.我认为会有一个完成上述或更一般任务的标准函数,但我无法弄清楚它会是什么.

当我第一次阅读严肃的批评时-XUndecidableInstances,我已经完全习惯了它,将其视为仅仅删除了令人讨厌的限制Haskell98必须使编译器更容易实现.

事实上,我遇到了大量需要不可判定实例的应用程序,但没有一处它们实际上导致任何与不可判定性相关的问题.卢克的例子存在问题,原因完全不同

class Group g where
  (%) :: g -> g -> g
  ...
instance Num g => Group g where
  ...

- 好吧,这显然会被任何适当的实例重叠Group,所以不可判断性是我们最不担心的事情:这实际上是不确定的!

但公平地说,我自己保留了"不可判断的实例可能会让编译器挂起".

当我在CodeGolf.SE上阅读这个挑战时获得它,请求代码无限地挂起编译器.嗯,听起来像是不可判断的实例的工作,对吧？

事实证明我无法让他们这样做.以下编译,至少从GHC-7.10开始:

{-# LANGUAGE FlexibleInstances, UndecidableInstances #-}
class C y
instance C y => C y
main = return ()

我甚至可以使用类方法,它们只会在运行时引起循环:

{-# LANGUAGE FlexibleInstances, UndecidableInstances #-}
class C y where y::y
instance C y => C y …

我正在尝试使用nightly-2017-08-17快照设置一个新项目

stack new test --resolver nightly-2017-08-17

但是,这会产生以下错误:

Downloading template "new-template" to create project "test" in test/ ...
Looking for .cabal or package.yaml files to use to init the project.
Using cabal packages:
- test/test.cabal

Selected resolver: nightly-2017-08-17
Unable to parse cabal file: FromString "This package requires at least Cabal version 2.0" Nothing

Cabal的最新版本:

stack setup --upgrade-cabal
Currently installed Cabal is 2.0.0.2, newest is 2.0.0.2. I'm not upgrading Cabal.
stack will use a sandboxed GHC it installed
For more …

Cabal或最近的GHC本身预先定义了CPP宏,允许检查使用哪个库的版本.它很容易在简单的例子中使用

#if MIN_VERSION_base(4,0,0)
... code that works with base-4 ...
#else
... code that works with base-3 ...
#endif

但是,CPP宏名称比Cabal包名称更受限制,因此以下不起作用:

#if !MIN_VERSION_quickcheck-instances(0,3,17)
instance Arbitrary SBS.ShortByteString where arbitrary = fmap SBS.pack arbitrary
#endif

     error: missing binary operator before token "("
     #if !MIN_VERSION_quickcheck-instances(0,3,17)
     ^
   |
18 | #if !MIN_VERSION_quickcheck-instances(0,3,17)
   | ^
`gcc' failed in phase `C pre-processor'. (Exit code: 1)

似乎没有正确记录如何处理这样的库名称.

说我有这样的事情

extern "C" void make_foo (char** tgt) {
  *tgt = (char*) malloc(4*sizeof(char));
  strncpy(*tgt, "foo", 4);
}

int main() {
  char* foo;
  make_foo(&foo);
  std::string foos{{foo}};
  free(foo);
  ...
  return 0;
}

现在，我想避免使用然后删除foo缓冲区。即，我想将初始化更改为foos类似

  std::string foos{{std::move(foo)}};

并且不使用显式free.

事实证明这实际上可以编译并且似乎可以工作，但我对此有一种相当怀疑的感觉：它是否真的移动了 C 定义的字符串并正确释放了存储？或者，std::move一旦foo指针超出范围，它是否只是忽略并泄漏存储？

并不是我太担心额外的副本，但我确实想知道是否有可能以现代移动语义风格来编写它。

我是 Haskell 新手，无法找出我的代码出了什么问题。我不断收到变量超出范围的错误。

这是我使用加载到 GHCi 中的代码:load

validLength :: String -> Bool
validLength xs | length xs == 26 = True
               | otherwise = False

然后我输入validLength aawhich 应该返回 false 但我收到错误。

*Main> validLength aa

<interactive>:1:13: error: Variable not in scope: aa :: String

我的代码有问题，如下所示：

import Data.List

splitat _ [] = ([],[])
splitat element (head:tail)
  | element == head = ([],(head:tail))
  | otherwise = ([head]++fst(splitat element tail), snd(splitat element tail))

它在“元素”处拆分列表，然后将左右子列表组合成一个元组。然而，在第三行中，'splitat element tail' 命令被调用两次，一次通过'fst'，一次通过'snd'。有没有办法只评估这个术语 1 次以保持递归树的狭窄？

提前致谢。