blocks|key|2349227|text|您可以通过将子表达式替换为(error+"x")、(error+"y")等来测试您的假设。首先评估的错误是在您运行表达式时出现的错误。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2349228|entityMap^0|D|B|P|B|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

You can test your hypothesis by replacing subexpressions by <code>(error "x")</code>, <code>(error "y")</code>, etc. Whichever error is evaluated first is the one to show up when you run the expression.

blocks|key|2301832|text|就这一点而言，只要得到正确的答案，求值就可以按照编译器希望的任何顺序进行。例如，它可以将整个表达式优化为23，并且在运行时根本没有求值。它可以先计算右侧算术运算符，然后再计算左侧运算符，减法除外。它可以在运行时随机决定首先评估哪一个。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2301833|忽略这一点，有关如何手动完成这项工作的解释，请参阅"How+Lazy+Evaluation+Works+in+Haskell"。|offset|length|2301834|2301835|但是如何手动解决这个问题并不是这个答案的重点。您的问题是Haskell实际上会使用什么求值顺序，所以这个答案大概是告诉您程序在使用您选择的编译器进行编译时所使用的求值顺序(忽略一些对基本理解求值顺序不重要的注意事项)。|2301836|通过一些工作，我们可以让Haskell告诉我们它的计算顺序。如果你在学校，你可能想学习如何在没有帮助的情况下手动查找评估顺序，这样你就可以在测试中取得好成绩。|2301837|建议您仅在检查您有信心的答案时才执行此操作。如果你被卡住了，你也可以使用它，但你应该只读到你卡住了的地方，看看下一步是什么，并对为什么是下一步做出有根据的猜测，这样你就可以开始通过实验来了解规则是什么。这与上面的链接文章相结合，将会有相当大的帮助。|2301838|为此，我们可以通过使用Debug.Trace的函数而不是error来扩展Jonas+Dureg&rd的答案。Debug.Trace的函数可以在开始或停止计算时输出结果，所以它们在这里非常合适：|style|CODE|2301839|import+Debug.Trace

--+Show+result
r+::+String+->+Int+->+Int
r+nm+n+=+trace+("Result+of+"+%2B%2B+nm+%2B%2B+"+is+"+%2B%2B+show+n)+n

--+Show+evaluation+of+Int+->+Int+->+Int+function
f+::+String+->+(Int+->+Int+->+Int)+->+Int+->+Int+->+Int
f+nm+g+a+b+=+e+nm+$+g+a+b

--+Show+evaluation+of+an+Int
e+::+String+->+Int+->+Int
e+nm+=+r+nm+.+trace+("Evaluating+"+%2B%2B+nm)

--+Show+Int+literal
i+::+Int+->+Int
i+n+=+e+(show+n)+n

multiply+::+Int+->+Int+->+Int
multiply+a+b+=+e+"multiply"+$+(f+"multiply's+*"+(*))
++++++++++++++++++++++++++++++(e+"multiply's+a"+a)
++++++++++++++++++++++++++++++(e+"multiply's+b"+b)

minus+::+Int+->+Int+->+Int
minus+a+b+=+e+"minus"+$+(f+"minus's+-"+(-))
++++++++++++++++++++++++(e+"minus's+a"+a)
++++++++++++++++++++++++(e+"minus's+b"+b)

minus2+::+Int+->+Int+->+Int
minus2+a+b+=+e+"minus2"+$+(f+"minus2's+-"+(-))
++++++++++++++++++++++++++(e+"minus2's+b"+b)
++++++++++++++++++++++++++(e+"minus2's+a"+a)

main+::+IO+()
main+=+print+$+minus2+(multiply+(minus+(i+3)+(i+5))+(i+7))+(i+9)|code-block|syntax|javascript|2301840|一旦你在纸上解决了问题，你可以用the+results+of+the+above+code+run+on+GHC检查你的答案。它告诉您使用GHC编译时您的代码使用的评估顺序。|2301841|您也可以选择通过您选择的Haskell编译器来运行它。|2301842|entityMap|0|LINK|mutability|MUTABLE|url|https://hackhands.com/lazy-evaluation-works-haskell/|1|https://ideone.com/BjTZNQ#stderr^0|0|P|12|0|0|0|0|0|0|B|B|S|5|1I|B|0|0|G|14|1|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1A|8|@]|9|@$D|1B|E|1C|1|1D]]|A|$]]|$1|F|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|1F|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1G|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1H|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1I|8|@$D|1J|E|1K|O|P]|$D|1L|E|1M|O|P]|$D|1N|E|1O|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|S|7|1P|8|@]|9|@]|A|$T|U]]|$1|V|3|W|5|6|7|1Q|8|@]|9|@$D|1R|E|1S|1|1T]]|A|$]]|$1|X|3|Y|5|6|7|1U|8|@]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]]|10|$11|$5|12|13|14|A|$15|16]]|17|$5|12|13|14|A|$15|18]]]]

To the point, evaluation can proceed in any order the compiler wants it to, as long as it gets the correct answer. For example, it could optimize the entire expression to 23 and have no evaluation at all at runtime. It could evaluate the right side of arithmetic operators before the left side, except for subtraction. It could randomly decide at runtime which to evaluate first.

Ignoring that, for an explanation of how to manually do the work, see <a href="https://hackhands.com/lazy-evaluation-works-haskell/" rel="nofollow noreferrer">"How Lazy Evaluation Works in Haskell"</a>.

<hr>

But how to manually figure it out is not the main point of this answer. Your question was what evaluation order Haskell would actually use, so this answer loosely intends to tell you the evaluation order your program uses when compiled with the compiler of your choice (ignoring some caveats that don't matter for basic understanding of evaluation order).

With some work, we can have Haskell tell us what order it evaluates in. If you're in school, you probably want to learn how to find the evaluation order manually without assistance so that you can do well on a test.

It's recommended that you only do this to check an answer you're confident in. You can also use it if you get stuck, but you should only read up until the point that you're stuck to see what the next step is and to make an educated guess about why that's the next step so that you can begin to learn what the rules are by experimenting. This, in combination with the above linked article, will help quite a bit.

To do this, we can expand upon Jonas Duregård's answer by using <code>Debug.Trace</code>'s functions instead of <code>error</code>. <code>Debug.Trace</code>'s functions can output things when something starts or stops being evaluated, so they're quite appropriate here:

<pre class="lang-hs prettyprint-override"><code>import Debug.Trace

-- Show result
r :: String -&gt; Int -&gt; Int
r nm n = trace ("Result of " ++ nm ++ " is " ++ show n) n

-- Show evaluation of Int -&gt; Int -&gt; Int function
f :: String -&gt; (Int -&gt; Int -&gt; Int) -&gt; Int -&gt; Int -&gt; Int
f nm g a b = e nm $ g a b

-- Show evaluation of an Int
e :: String -&gt; Int -&gt; Int
e nm = r nm . trace ("Evaluating " ++ nm)

-- Show Int literal
i :: Int -&gt; Int
i n = e (show n) n

multiply :: Int -&gt; Int -&gt; Int
multiply a b = e "multiply" $ (f "multiply's *" (*))
 (e "multiply's a" a)
 (e "multiply's b" b)

minus :: Int -&gt; Int -&gt; Int
minus a b = e "minus" $ (f "minus's -" (-))
 (e "minus's a" a)
 (e "minus's b" b)

minus2 :: Int -&gt; Int -&gt; Int
minus2 a b = e "minus2" $ (f "minus2's -" (-))
 (e "minus2's b" b)
 (e "minus2's a" a)

main :: IO ()
main = print $ minus2 (multiply (minus (i 3) (i 5)) (i 7)) (i 9)
</code></pre>

Once you've solved the problem on paper, you can check your answer with <a href="https://ideone.com/BjTZNQ#stderr" rel="nofollow noreferrer">the results of the above code run on GHC</a>. It tells you what evaluation order your code uses when compiled with GHC.

You can alternatively run this through the Haskell compiler of your choice.

<pre><code>multiply :: Int -&gt; Int -&gt; Int 
multiply a b = a * b 

minus :: Int -&gt; Int -&gt; Int 
minus a b = a - b 

minus2 :: Int -&gt; Int -&gt; Int 
minus2 a b = b – a


minus2 (multiply (minus 3 5) 7) 9
minus2 ((minus 3 5) * 7) 9
9 - ((minus 3 5) * 7)
9 - ((3 - 5) * 7)
9 - ((-2) * 7)
9 - (-14)
23
</code></pre>

Running the line <code>minus2 (multiply (minus 3 5) 7) 9</code>
Do I have the correct order of evaluation that Haskell would use?

Still new with functional programming so I'm not sure if I have the "lazy evaluation" process correct.

Regarding evaluation order

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

multiply :: Int -> Int -> Int multiply a b = a * b minus :: Int -> Int -> Int minus a b = a - b minus2 :: Int -> Int -> Int minus2 a b = b – aminus2 (multiply (...

问关于评估顺序
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问关于评估顺序EN