blocks|key|300887|text|严格函数是指在计算正文之前计算其参数的函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|300888|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

A strict function is a function whose arguments are evaluated before the body is.

blocks|key|4424764|text|foldl和(严格的)+foldl‘在语义上几乎是等价的。不同之处在于性能，特别是在遍历大型列表时。懒惰有一个构建thunk的开销，而foldl‘是达到这个结果的更有效的方法，因为它不会构建一个巨大的thunk。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4424765|在Haskell+Wiki上有一篇非常好的文章详细解释了这一点|offset|length|4424766|严格函数的工作原理类似于C或其他语言中的函数，因为它们的参数通常会被迫切地计算出来。|4424767|entityMap|0|LINK|mutability|MUTABLE|url|http://www.haskell.org/haskellwiki/Foldr_Foldl_Foldl%2527^0|0|1|C|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

foldl and (the strict) foldl' are close to semantically equivalent. The difference is in performance, especially when you are transversing a large list. The laziness has an overhead of building a thunk and foldl' is the more efficient way to arrive at that result because it doesn't build a huge thunk. 

There is a really good article explaining this in detail on <a href="http://www.haskell.org/haskellwiki/Foldr_Foldl_Foldl%27" rel="nofollow">Haskell Wiki</a>

Strict functions works like functions in C or other languages in that their arguments are generally eagerly evaluated.

blocks|key|4424893|text|回想一下类型：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4424894|foldl'+::+(a+->+b+->+a)+->+a+->+[b]+->+a|code-block|syntax|javascript|4424895|它在参数2中的严格程度取决于为参数1指定的函数的严格程度，如果您传递const，就会看到这一点|offset|length|style|CODE|4424896|Prelude+Data.List>+foldl'+(const+(%2B1))+undefined+[1]
2
Prelude+Data.List>+foldl'+(const+(%2B1))+undefined+[1..4]
5|4424897|你可能会天真地认为，"foldl‘is+strict“的意思是”严格的累加器参数“。上述情况与此相矛盾。|4424898|然而，它甚至更加隐蔽，因为严格程度只在循环的cons情况下函数应用的结果上。|4424899|Prelude+Data.List>+foldl'+(const+(%2B1))+undefined+[]
***+Exception:+Prelude.undefined|4424900|所以in+argument+2的严格性也取决于参数3的值！|4424901|我是这样写的:在它的第二个参数中“完全”严格。|4424902|foldl'+f+z0+xs0+=+go+z0+xs0
++where
++++go+!z+[]+++++=+z
++++go+!z+(x:xs)+=+go+(f+z+x)+xs|4424903|4424904|Prelude+Data.List.Stream>+foldl'+(\a+b+->+1)+undefined+[undefined]
***+Exception:+Prelude.undefined|4424905|与Haskell2010版本相比：|4424906|Prelude+Data.List.Stream>+Data.List.foldl'+(\a+b+->+1+)+undefined+[undefined]
1|4424907|这实际上有一个实际的影响--当前的定义不会一致地拆开它的累加器参数。|4424908|历史注释:这是我们在2007年为流融合论文指定列表库的严格语义时发现的，并且在Duncan+Coutt的PhD+thesis中给出了指定严格程度的方法。|4424909|entityMap|0|LINK|mutability|MUTABLE|url|http://hackage.haskell.org/packages/archive/base/latest/doc/html/src/Data-List.html#foldl%2527|1|http://community.haskell.org/~duncan/thesis.pdf^0|0|0|Y|5|0|0|0|0|0|2|D|0|0|0|0|0|0|0|0|0|1G|A|1|0^^$0|@$1|2|3|4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1N|8|@$I|1O|J|1P|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|1Q|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1R|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1S|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1T|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1U|8|@]|9|@$I|1V|J|1W|1|1X]]|A|$]]|$1|W|3|X|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1Z|8|@]|9|@]|A|$E|F]]|$1|10|3|-4|5|6|7|20|8|@]|9|@]|A|$]]|$1|11|3|12|5|D|7|21|8|@]|9|@]|A|$E|F]]|$1|13|3|14|5|6|7|22|8|@]|9|@]|A|$]]|$1|15|3|16|5|D|7|23|8|@]|9|@]|A|$E|F]]|$1|17|3|18|5|6|7|24|8|@]|9|@]|A|$]]|$1|19|3|1A|5|6|7|25|8|@]|9|@$I|26|J|27|1|28]]|A|$]]|$1|1B|3|-4|5|6|7|29|8|@]|9|@]|A|$]]]|1C|$1D|$5|1E|1F|1G|A|$1H|1I]]|1J|$5|1E|1F|1G|A|$1H|1K]]]]

It is not widely known, but <code>foldl'</code> is actually non-strict in its accumulator argument! Recall the type:

<pre><code>foldl' :: (a -&gt; b -&gt; a) -&gt; a -&gt; [b] -&gt; a
</code></pre>

Its strictness in argument 2 depends on the strictness of the function given for argument 1, as you see if you pass <code>const</code>:

<pre><code>Prelude Data.List&gt; foldl' (const (+1)) undefined [1]
2
Prelude Data.List&gt; foldl' (const (+1)) undefined [1..4]
5
</code></pre>

You would have thought, naively, that "foldl' is strict" means "strict in the accumulator argument". The above contradicts that.

However, it is even more insidious, as the strictness is only on the result of the function application in the cons case of the loop. So you still get bottoms if you enter the base case, but not the inductive case:

<pre><code>Prelude Data.List&gt; foldl' (const (+1)) undefined []
*** Exception: Prelude.undefined
</code></pre>

So the strictness <a href="http://hackage.haskell.org/packages/archive/base/latest/doc/html/src/Data-List.html#foldl%27">in argument 2</a> also depends on the value of argument 3!

This is how I'd write it: "fully" strict in its 2nd argument.

<pre><code>foldl' f z0 xs0 = go z0 xs0
 where
 go !z [] = z
 go !z (x:xs) = go (f z x) xs
</code></pre>

Which is truly strict in its second argument, as you can see :

<pre><code>Prelude Data.List.Stream&gt; foldl' (\a b -&gt; 1) undefined [undefined]
*** Exception: Prelude.undefined
</code></pre>

Compared with the Haskell2010 version:

<pre><code>Prelude Data.List.Stream&gt; Data.List.foldl' (\a b -&gt; 1 ) undefined [undefined]
1
</code></pre>

This actuall has a practical impact -- the current definition will not unbox its accumulator argument consistently.

Historical note: this was discovered when we were specifying the list library's strictness semantics for the stream fusion paper in 2007, and the approach to specifying strictness is given in Duncan Coutt's <a href="http://community.haskell.org/~duncan/thesis.pdf">PhD thesis</a>.

Follow &lt;Real World Haskell&gt; , it is said <code>foldl'</code> are strict version of <code>foldl</code>.

But it's hard for me to understand , what does <code>strict</code> mean??

<pre><code>foldl f z0 xs0 = lgo z0 xs0
 where
 lgo z [] = z
 lgo z (x:xs) = lgo (f z x) xs


foldl' f z0 xs0 = lgo z0 xs0
 where lgo z [] = z
 lgo z (x:xs) = let z' = f z x in z' `seq` lgo z' xs
</code></pre>

What's the meaning of strict version in haskell?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

下面，据说foldl'都是严格版的foldl。但是我很难理解，strict是什么意思？？foldl f z0 xs0 = lgo z0 xs0         where            lgo z []     =  z            lgo z (x:xs) = lgo (f z x) xsfoldl...

问在haskell中严格版本是什么意思？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在haskell中严格版本是什么意思？EN