blocks|key|1624309|text|max+6.7接受一个Double并返回一个Double。replicate+5获取一个Double并生成一个[Double]。sum接受[Double]并返回Double类型的内容。(在类型推断之后。)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1624310|.只是将所有这些函数链接在一起，所以只剩下一个Double+->+Double类型的函数。然后将8.9传递给该函数。|1624311|entityMap^0|0|7|B|6|M|6|T|B|18|6|1J|8|1S|3|1X|8|28|6|0|0|1|N|G|1C|3|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|I|$]]

<code>max 6.7</code> takes a <code>Double</code> and returns a <code>Double</code>. <code>replicate 5</code> takes a <code>Double</code> and makes a <code>[Double]</code>. <code>sum</code> takes a <code>[Double]</code> and returns something of type <code>Double</code>. (after type inference.)

<code>.</code> just chains all of these functions together, so you're left with a function of type <code>Double -&gt; Double</code>. Then you pass <code>8.9</code> to that function.

blocks|key|1624453|text|如果您编写f+.+g，这基本上是\x+->+f+(g+x)的缩写。由于(.)运算符是右关联的，因此您的函数等价于：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1624454|=++++(sum+.+replicate+5+.+max+6.7)+8.9
--------------------------------------
+++(sum+.+(replicate+5+.+max+6.7))+8.9|code-block|syntax|javascript|1624455|和：|1624456|=++++++++++++++++++++(sum+.+(replicate+5+.+max+6.7))+8.9
--------------------------------------------------------
+++(\x+->+sum+((\y+->+(replicate+5+(max+6.7+y)))+x))+8.9|1624457|所以现在如果我们执行评估，我们会看到：|1624458|=++(\x+->+sum+((\y+->+(replicate+5+(max+6.7+y)))+x))+8.9
--------------------------------------------------------
+++++++++++++sum+((\y+->+(replicate+5+(max+6.7+y)))+8.9)|1624459|1624460|=++sum+((\y+->+(replicate+5+(max+6.7+y)))+8.9)
----------------------------------------------
+++++++++++++++sum+(replicate+5+(max+6.7+8.9))|1624461|因此，函数组合将首先将8.9作为max的第二个参数，然后以某种从右到左的链式将所有其他函数应用于结果。|1624462|entityMap^0|5|5|G|D|Z|3|0|0|0|0|0|0|0|0|B|3|G|3|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|17|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|19|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|S|3|L|5|6|7|1B|8|@]|D|@]|E|$]]|$1|T|3|U|5|H|7|1C|8|@]|D|@]|E|$I|J]]|$1|V|3|W|5|6|7|1D|8|@$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|X|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]]|Y|$]]

If you write <code>f . g</code>, this is basically short for <code>\x -&gt; f (g x)</code>. Since the <code>(.)</code> operator is right associative your function is equivalent to:

<pre><code>= (sum . replicate 5 . max 6.7) 8.9
--------------------------------------
 (sum . (replicate 5 . max 6.7)) 8.9
</code></pre>

and:

<pre><code>= (sum . (replicate 5 . max 6.7)) 8.9
--------------------------------------------------------
 (\x -&gt; sum ((\y -&gt; (replicate 5 (max 6.7 y))) x)) 8.9
</code></pre>

So now if we perform evaluation, we see:

<pre><code>= (\x -&gt; sum ((\y -&gt; (replicate 5 (max 6.7 y))) x)) 8.9
--------------------------------------------------------
 sum ((\y -&gt; (replicate 5 (max 6.7 y))) 8.9)
</code></pre>

and:

<pre><code>= sum ((\y -&gt; (replicate 5 (max 6.7 y))) 8.9)
----------------------------------------------
 sum (replicate 5 (max 6.7 8.9))
</code></pre>

So the function composition will first place the <code>8.9</code> as second parameter of the <code>max</code>, and then apply all other functions to the result in some sort of chain from right-to-left.

blocks|key|1839122|text|如果你理解(sum+.+replicate+5+.+max+6.7)这一部分，那么你就知道它返回了一个函数，它将最大值6.7和给定的数重复5次。这个新函数的类型是Float+->+Float。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1839123|所以接下来我们对这个函数应用8.9，我们得到最终的值。我们可以用更直观的方式来写它：|1839124|mySum+::+Float+->+Float
mySum+=+sum+.+replicate+5+.+max+6.7

result+::+Float
result+=+mySum+8.9|code-block|syntax|javascript|1839125|entityMap^0|5|T|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|S|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

If you understand the part <code>(sum . replicate 5 . max 6.7)</code> then you know that it returns a function that sums the maximum number of 6.7 and given number replicated 5 times. The type of this new function is Float -> Float.

So next we apply 8.9 to this function and we get final value. We can write it in more intuitive way:

<pre><code>mySum :: Float -&gt; Float
mySum = sum . replicate 5 . max 6.7

result :: Float
result = mySum 8.9
</code></pre>

blocks|key|1839256|text|Haskell中的函数是curried的。一个curried函数，它有两个参数值，只能与一个参数值一起使用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1839257|f+=+max+2
f+3|code-block|syntax|javascript|1839258|3.|1839259|当你写max+2+3时，它实际上被转换成(max+2)，参数为3，(max+2)+3是Haskell正在做的事情。|offset|length|style|CODE|1839260|这使它本身成为无指针的代码。您不必指定函数或函数组合的最后一个参数，但在调用函数或函数组合时必须提供该参数。|1839261|entityMap^0|0|0|0|3|7|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@$K|W|L|X|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Functions in Haskell are curried. A curried function that otherwise takes two parameter values you can use with only one.

<pre><code>f = max 2
f 3
</code></pre>

3

When you write <code>max 2 3</code> it is actually translated into (max 2) with a parameter 3, (max 2) 3 is what Haskell is doing anyway.

This lends itself to point-free code. You do not have to specify the final parameter of a function or function composition but do have to supply it when calling the function or functions composition.

Rewrite <code>(sum . replicate 5 . max 6.7) 8.9</code> using function composition. We have 

<code>(sum . replicate 5 . max 6.7) 8.9</code>

I understand the part <code>(sum . replicate 5 . max 6.7)</code>. But then how does it deal with <code>8.9</code>?

edit from comments: turns out, the <code>.</code> in <code>6.7</code> is not a function composition operator, but a decimal dot!

How does `sum (replicate 5 (max 6.7 8.9))` and `(sum . replicate 5 . max 6.7) 8.9` get the same result?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

使用函数组合重写(sum . replicate 5 . max 6.7) 8.9。我们有(sum . replicate 5 . max 6.7) 8.9我明白(sum . replicate 5 . max 6.7)的意思了。但是它是如何处理8.9的呢注释编辑:原来，6.7中的.不是函数复合运算符，而是一个小数点！

问重复5次。
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问重复5次。EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问重复5次。
EN