小编Dmi*_*lov的帖子

我试图让我的程序在没有boost使用的情况下工作,但是找不到某些有用模式的替代方案.也就是说,我boost::optional在标准库中找不到-likewise模式.是否有boost::optional(C++ 11或其他地方)的标准替代方案？

Haskell不支持循环计算,而是提供使用递归算法.但是这种方法导致堆栈增长,甚至堆栈溢出.我认为应该有办法解决这个问题.这是样本.我想知道,每5秒可以调用多次getClockTime:

import System.Time

nSeconds = 5

main = do
    initTime <- totalPicoSeconds `fmap` getClockTime
    doWork initTime 1
    where
    doWork initTime n = do
        currTime <- totalPicoSeconds `fmap` getClockTime
        if (currTime - initTime) `div` 10 ^ 12 >= nSeconds
            then print n
            else doWork initTime (n+1)

totalPicoSeconds :: ClockTime -> Integer
totalPicoSeconds (TOD a b) = a * 10 ^ 12 + b

该程序耗时5秒,但最终我得到了:

堆栈空间溢出:当前大小为8388608字节.
使用`+ RTS -Ksize -RTS'来增加它.

在特定情况下,手动管理堆栈大小可能有所帮助,但如果我希望运行此算法10秒钟,它可能会再次溢出.所以这不是一个解决方案.我怎样才能使这段代码有效？

例如,我有一个fnB :: a -> Bool在fnA :: Bool返回之前没有意义的操作False.CI中可以将这两个操作组合在一个if块中:

if( fnA && fnB(a) ){ doSomething; }

和C将保证fnB在fnA返回false 之前不会执行.

但Haskell是惰性的,并且,通常也不能保证什么操作将首先执行,直到我们不使用seq,$!或别的东西,使我们的代码严格.一般来说,这就是我们需要快乐的事情.但是使用&&运算符,我希望fnB在fnA返回结果之前不会对其进行求值.Haskell提供这样的保证&&吗？fnB即使fnA返回False,Haskell也会评估吗？

大多数语言,使用垃圾收集器(可能都是这些),有一个与并行计算相关的主要问题:垃圾收集器必须停止所有正在运行的线程才能删除未使用的对象.Haskell也有垃圾收集器.但是,由于纯度,Haskell保证没有计算改变原始数据,而是生成副本,然后进行更改.我想,通过这种方式,GC不必停止所有线程来完成它的工作.我只是好奇:Haskell是否与垃圾收集有相同的问题？

假设,我在使用IO时获得了大量项目:

as <- getLargeList

现在,我想申请fn :: a -> IO b到as:

as <- getLargeList
bs <- mapM fn as

mapM有类型mapM :: Monad m => (a -> m b) -> [a] -> m [b],这就是我在类型匹配方面所需要的.但它会在内存中构建所有链,直到返回结果.我正在寻找模拟器mapM,它会懒散地工作,所以我可以使用头部,bs而尾部仍然在建造.

有没有办法增加一个时间间隔,在此基础上RTS决定该线程在STM事务中无限期地被阻塞？这是我的代码:

import Control.Concurrent (ThreadId)
import Control.Concurrent.MVar (MVar,newMVar,withMVar)
import Control.Concurrent.STM
import qualified Control.Concurrent.ThreadManager as TM

data ThreadManager = ThreadManager { tmCounter::TVar Int, tmTM::MVar TM.ThreadManager }

data Settings = Settings {
    maxThreadsCount::Int }

createThreadManager :: Settings -> IO ThreadManager
createThreadManager s = do
    counter <- atomically $ newTVar (maxThreadsCount s)
    tm <- TM.make >>= newMVar
    return $ ThreadManager counter tm

forkManaged :: ThreadManager -> IO () -> IO ThreadId
forkManaged tm fn = do
    atomically $ do
        counter <- readTVar $ tmCounter …

我在SBT下有多模块项目.

项目A(库)具有reference.conf包含A配置参数的文件.项目A依赖于akka-actor库,它随附自己的reference.conf文件.项目A重新定义了一些akka自己的参数reference.conf.

项目B取决于A.

当我打电话ConfigFactory.load()时B,我reference.conf的合并顺序错了.首先需要A配置,然后akka-actor在其上应用配置.最终,我正在进行初始akka-actor配置.

我该如何解决？我需要akka-actor首先加载配置,然后我A的配置应该应用于它.

我在Scala中有简单的类型层次结构:

trait A {
    trait A1
}

object B extends A {
    case object B1 extends A1
}

object C extends A {
    case object C1 extends A1
}

而且,我将使用这样的类型:

def get(): Any = C.C1

get() match {
    case _: B.A1 => println("B")
    case _: C.A1 => println("C")
    case _: A#A1 => println("Any")
}

令人惊讶的是,我正在B打印(我已经预料到了C).

为什么编译器将其C.C1视为实例B.A1？

如果我理解正确,Haskell中的异常基本上是为了处理IO monad.至少可以在IO monad中捕获异常.

但有时即使是纯函数也可能抛出异常,例如read "..." :: Int(当读取字符串不表示整数时),运算符(!!)(当我们试图使项目超出列表范围时),等等.这是真实的行为,我不否认.但是,我不想更改函数的签名只是为了抓住可能的异常,因为在这种情况下我必须通过调用堆栈更改签名所有函数.

在IO monad中,是否有一些模式可以处理Haskell中更为舒适的异常？可能我应该unsafePerformIO在这种情况下使用？如何"安全" unsafePerformIO仅用于捕获纯函数中的异常？

模块Data.ByteString.Lazy包含自己的ByteString类型实现：

data ByteString = Empty | Chunk !S.ByteString ByteString

而有大约块大小短语以下几点：

默认的块大小是 64k，这在大多数情况下应该是好的。对于拥有大型 L2 缓存的人，您可能需要增加它以适应您的缓存。

但没有关于如何做到这一点。如何增加默认块大小？另外，如果chuck大小会明显大于那些L2缓存，我是否会获得性能提升？

我刚开始学习模板Haskell,并坚持使用拼接的简单问题.
在一个模块中,我实现了tupleN回复元组的第N个元素的函数:

tupleN :: Lift a => a -> Int -> Q Exp
tupleN a n = do
   (TupE as) <- lift a
   return $ as !! n

在Main模块中,我有:

main :: IO ()
main = do
   let tup = (1::Int,'a',"hello")
   putStrLn $ show $(tupleN $tup 1)

这似乎有效,但事实并非如此.编译器打印错误:

GHC stage restriction: `tup'
  is used in a top-level splice or annotation,
  and must be imported, not defined locally
In the expression: tup
In the first argument of `tupleN', namely `$tup' …

假设,我定义了案例类:

case class A(id: Int)

然后我突然输入了这段代码:

val a = A

问题是 - 为什么编译器允许这样的着作？在Java中,使用任何参数定义构造函数会使默认构造函数不可用.

编辑:好的,正如Ende Neu指出的那样,a现在包含了A.type.如何突然输入a = A可能会破坏我的代码:

a match {
   case A(id) => do something
   case _ => I didn't expect fall into here
}

我试图避免陷入我的Akka消息处理代码中的第二种情况.可能吗？

更新:花了一些时间与Akka + Scala一起工作后,我想出了这个问题第二部分的答案.Actor的receive方法有签名PartialFunction[Any, Unit],这意味着输入参数没有类型检查.所以任何类型都被接受,包括A.type.在此上下文中对用户的最佳建议:在向演员发送消息时要小心.