这应该是一个非常简单的问题,但我似乎无法找到正确的解决方案.格式中有一个字符串:
A:B=C;D:E=F;G:E=H;...
而A,B和C是字母数字(并且可以更低,也可以是大写).A和B的长度为1+,C可以为空.
我想我必须使用类似的东西
((?<A>.+):(?<B>.+)=(?<C>.*);)*
但我不知道如何以懒惰的方式使它匹配.我也不确定如何获得相应匹配的结果,所以我很感激一些代码示例.
如果你能给我一个提示,我会很高兴的.
基本上,我有一个单元测试,可以获得一个类的单例实例.我的一些测试要求我模拟这个单例,所以当我做Foo.Instance我得到一个不同类型的实例.
问题是我的检查单独传递,但整体失败,因为一个测试正在干扰另一个测试.
我尝试在我设置的TestCleanup中执行:Foo_Accessor._instance = null;但这不起作用.我真正需要的是Foo_Accessor._instance.IsValueCreated = false;(_instance是一个懒惰的人).
有没有办法取消我没想到的Lazy对象？
我有两个类似于filter和的功能takeWhile.
filterAcc, takeWhileAcc :: ([a] -> Bool) -> [a] -> [a]
filterAcc p xs = go xs []
where go [] acc = acc
go (x:xs) acc
| p (x:acc) = go xs (x:acc)
| otherwise = go xs acc
takeWhileAcc p xs = go xs []
where go [] acc = acc
go (x:xs) acc
| p (x:acc) = go xs (x:acc)
| otherwise = acc
他们都采取谓词和列表,以及他们从正规的不同filter,并takeWhile在该谓词采取累积结果作为输入.
我的问题是,虽然filter even [1..] …
我找到了有关如何通过使用lazy val将重写的成员值传播给超类构造函数的解释。不幸的是，本文没有解释为什么这样做。
我知道不能将非惰性值分配两次，因此，在超级构造函数中没有可用的值，因为必须跳过超类构造函数中的值分配，才能不将变量锁定为另一个值。但是，如何在超级构造函数中执行的println语句（即在分配新的惰性值之前）已经知道此新值？我是否对执行顺序感到困惑？还是println以某种方式仅在构造对象之后才评估其参数？
我已经阅读了https://www.haskell.org/haskellwiki/Foldl_as_foldr和其他一些关于foldl和foldr之间区别的博客文章.现在我正在尝试将斐波那契序列作为带有折叠器的无限列表编写,我想出了以下解决方案:
fibs2 :: [Integer]
fibs2 = foldr buildFibs [] [1..]
where
buildFibs :: Integer -> [Integer] -> [Integer]
buildFibs _ [] = [0]
buildFibs _ [0] = [1,0]
buildFibs _ l@(x:s:z) = (x + s):l
但是当我这样做时take 3 fibs2,函数不会返回.我认为折叠是身体递归允许你在这些类型的情况下使用无限列表.为什么这不适合我的解决方案？
已经讨论过,mapM这里本来就不是懒惰的,例如这里和这里.现在我正在努力解决这个问题的变化,其中mapM问题是在monad变换器堆栈内部.
这是一个函数,它取自我在gist.github.com上使用的LevelDB的具体,工作(但是空间泄漏)的例子:
-- read keys [1..n] from db at DirName and check that the values are correct
doRead :: FilePath -> Int -> IO ()
doRead dirName n = do
success <- runResourceT $ do
db <- open dirName defaultOptions{ cacheSize= 2048 }
let check' = check db def in -- is an Int -> ResourceT IO Bool
and <$> mapM check' [1..n] -- space leak !!!
putStrLn $ if …我是函数式编程的新手,我想要了解懒惰的评估是如何工作的.我有以下功能:
nats = 0:(map (+1) nats)
test = foldr (\x y-> if x > 2 then 0 else x+y) 10 nats
而据我所知,第一个得到所有自然数的列表,直到它耗尽内存(但从来没有真正发生过,我理解),第二个应该做的正是什么？测试有一个lambda演算函数,它得到一个x和y,如果x> 2和x + y,则返回2,但这是否意味着它将返回0,因为x = 10？我有点困惑.在那种情况下,nat真的需要吗？
编辑:测试返回3,但现在我真的很困惑,因为我不明白如何.
如果我犯了一些菜鸟错误,谢谢,抱歉,但我不明白这是怎么回事.
struct Person
{
var personName:String?
init(name:String) {
personName=name
}
lazy var greetLazy:String =
{
return "Hello \(self.personName!)"
}()
func greetFunc()->String
{
return "Hello \(self.personName!)"
}
}
var person:Person=Person(name:"")
print(person.greetLazy)
print(person.greetFunc())
我创造了两件事,即一个懒惰的属性和一个做同样事情的功能.现在它说greetLazy的值只会在第一次访问时计算出来,所以当我使用person.greetLazy访问它时,它会打印到控制台,这就是懒惰应该是什么意思.
我的问题是在函数的情况下,只有在我访问函数时才会返回值.它不会预先计算它.那么在这种情况下两者之间会有什么区别呢？
我已经看到使用流作为comonad的默认示例,但我无法确定它们是如何无限的,但不是.
假设我们有数据构造函数(从这里)
data Stream a = a :> Stream a
我们如何最终完成一个流？我们在最后写了一个未定义的吗？我知道这种语言是懒惰的,但某些地方必须削减,对吧？我错了吗？
我是Clojure的新手.我有以下代码,它创建了一个无限懒惰的数字序列:
(defn generator [seed factor]
(drop 1 (reductions
(fn [acc _] (mod (* acc factor) 2147483647))
seed
; using dummy infinite seq to keep the reductions going
(repeat 1))))
序列中的每个数字都取决于先前的计算.我正在使用,reductions因为我需要所有中间结果.
然后我实例化两个生成器,如下所示:
(def gen-a (generator 59 16807))
(def gen-b (generator 393 48271))
然后我想比较n这些序列的连续结果,对于大n,并返回它们相等的次数.
起初我做了类似的事情:
(defn run []
(->> (interleave gen-a gen-b)
(partition 2)
(take 40000000)
(filter #(apply = %))
(count)))
这花了太长时间,我看到该程序的内存使用量飙升至约4GB.有些printlns我看到它经过大约1000万次迭代后变得非常慢,所以我想可能count需要将整个序列存储在内存中,所以我把它更改为使用reduce:
(defn run-2 []
(reduce
(fn [acc [a b]]
(if (= …lazy-evaluation ×10
haskell ×5
c# ×2
clojure ×1
constructor ×1
function ×1
infinite ×1
memory ×1
monads ×1
performance ×1
recursion ×1
regex ×1
scala ×1
sequence ×1
singleton ×1
stream ×1
swift ×1
unit-testing ×1