blocks|key|783183|text|当您不需要高阶函数的所有灵活性时，它对于传递到高阶函数非常有用。例如，一元序列运算符>>可以根据一元绑定运算符定义为|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|783184|x+>>+y+=+x+>>=+const+y|code-block|syntax|javascript|783185|它比使用lambda更简洁|783186|x+>>+y+=+x+>>=+\_+->+y|783187|你甚至可以不用指针就可以使用它|783188|(>>)+=+(.+const)+.+(>>=)|783189|尽管在这种情况下我并不特别推荐这样做。|783190|entityMap^0|16|2|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|12|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|14|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|V|$]]

It's useful for passing to higher-order functions when you don't need all their flexibility. For example, the monadic sequence operator <code>&gt;&gt;</code> can be defined in terms of the monadic bind operator as

<pre><code>x &gt;&gt; y = x &gt;&gt;= const y
</code></pre>

It's somewhat neater than using a lambda

<pre><code>x &gt;&gt; y = x &gt;&gt;= \_ -&gt; y
</code></pre>

and you can even use it point-free

<pre><code>(&gt;&gt;) = (. const) . (&gt;&gt;=)
</code></pre>

although I don't particularly recommend that in this case.

blocks|key|566994|text|Data.Functor.(<$)是使用const的一个简单示例。有了这个函数，你可以说:我这里有一个函数器，里面有一些无聊的东西，但我想要在它里面有另一个有趣的东西，而不改变函数器的形状。例如。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|566995|import+Data.Functor

42+<$+Just+"boring"
-->+Just+42

42+<$+Nothing
-->+Nothing

"cool"+<$+["nonsense","stupid","uninteresting"]
-->+["cool","cool","cool"]|code-block|syntax|javascript|566996|它的定义是：|566997|(<$)+::+a+->+f+b+->+f+a
(<$)+=++fmap+.+const|566998|或者写成不是毫无意义的：|566999|cool+<$+uncool+=++fmap+(const+cool)+uncool|567000|您可以看到这里如何使用const来“忘记”输入。|567001|entityMap^0|0|H|K|5|0|0|0|0|0|0|B|5|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|V|$]]

A simple example for using <code>const</code> is <code>Data.Functor.(&lt;$)</code>. With this function you can say: I have here a functor with something boring in it, but instead I want to have that other interesting thing in it, without changing the shape of the functor. E.g.

<pre><code>import Data.Functor

42 &lt;$ Just "boring"
--&gt; Just 42

42 &lt;$ Nothing
--&gt; Nothing

"cool" &lt;$ ["nonsense","stupid","uninteresting"]
--&gt; ["cool","cool","cool"]
</code></pre>

The definition is:

<pre><code>(&lt;$) :: a -&gt; f b -&gt; f a
(&lt;$) = fmap . const
</code></pre>

or written not as pointless:

<pre><code>cool &lt;$ uncool = fmap (const cool) uncool
</code></pre>

You see how <code>const</code> is used here to "forget" about the input.

blocks|key|783274|text|另一个用途是实现具有不应计算的伪参数的类成员函数(用于解析不明确的类型)。示例可能是Data.bits格式的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|783275|instance+Bits+Int+where
++isSigned+=+const+True
++bitSize++=+const+wordSize
++...|code-block|syntax|javascript|783276|通过使用const，我们显式地表示我们正在定义常量值。|783277|就我个人而言，我不喜欢使用伪参数，但如果在类中使用它们，那么这是编写实例的一种相当好的方式。|783278|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Another use is to implement class member functions that have a dummy argument which should not be evaluated (used to resolve ambiguous types). Example that could be in Data.bits:

<pre><code>instance Bits Int where
 isSigned = const True
 bitSize = const wordSize
 ...
</code></pre>

By using const we explicitly say that we are defining constant values.

Personally I dislike the use of dummy parameters, but if they are used in a class then this is a rather nice way of writing instances.

blocks|key|567077|text|const可能就是您正在寻找的与其他函数结合使用的实现。这是我发现的一个例子。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|567078|假设我们想要将一个二元组结构重写为另一个二元组结构。我可以这样表达：|567079|((a,b),(c,d))+⇒+(a,(c,(5,a)))|code-block|syntax|javascript|567080|我可以用模式匹配给出一个简单的定义：|567081|f+((a,b),(c,d))+=+(a,(c,(5,a)))|567082|如果我想要一个毫无意义的(默契的)解决方案来处理这些重写，该怎么办呢？经过一番思考和摆弄之后，答案是我们可以用(&&&),+const,+(.),+fst,+snd来表达任何重写。请注意，(&&&)来自Control.Arrow。|567083|使用这些函数的示例的解决方案是：|567084|(fst.fst+&&&+(fst.snd+&&&+(const+5+&&&+fst.fst)))|567085|注意与(a,(c,(5,a)))的相似性。如果我们用,替换&&&呢？然后它会显示为：|567086|(fst.fst,+(fst.snd,+(const+5,+fst.fst)))|567087|请注意，a是第一个元素的第一个元素，这就是fst.fst项目。请注意，c是第二个元素的第一个元素，这就是fst.snd的项目。也就是说，变量成为其源代码的路径。|567088|const允许我们引入常量。有趣的是它的名字和它的意思是一致的！|567089|然后我用Applicative概括了这个想法，这样你就可以用一种毫无意义的风格来编写任何函数(只要你有可用的案例分析作为函数，比如maybe，either，bool)。同样，const扮演了引入常量的角色。您可以在Data.Function.Tacit包中看到这项工作。|567090|当你从抽象的目标开始，然后朝着实现的方向努力时，你可能会对答案感到惊讶。也就是说，任何一个功能都可能像机器中的任何一个齿轮一样神秘。但是，如果您将整个机器放在视线中，您就可以理解需要该齿轮的上下文。|567091|entityMap|0|LINK|mutability|MUTABLE|url|http://hackage.haskell.org/package/data-function-tacit-0.1.0.0/docs/Data-Function-Tacit.html^0|0|5|0|0|0|0|0|1J|R|2M|5|2T|D|0|0|0|3|D|Q|1|T|3|0|0|4|1|L|7|Z|1|1G|7|0|0|5|0|1T|5|1Z|6|26|4|2F|5|2Z|J|0|0|0^^$0|@$1|2|3|4|5|6|7|1G|8|@$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1J|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1K|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1L|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1M|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1N|8|@$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1U|8|@]|D|@]|E|$]]|$1|U|3|V|5|J|7|1V|8|@]|D|@]|E|$K|L]]|$1|W|3|X|5|6|7|1W|8|@$9|1X|A|1Y|B|C]|$9|1Z|A|20|B|C]|$9|21|A|22|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|J|7|23|8|@]|D|@]|E|$K|L]]|$1|10|3|11|5|6|7|24|8|@$9|25|A|26|B|C]|$9|27|A|28|B|C]|$9|29|A|2A|B|C]|$9|2B|A|2C|B|C]]|D|@]|E|$]]|$1|12|3|13|5|6|7|2D|8|@$9|2E|A|2F|B|C]]|D|@]|E|$]]|$1|14|3|15|5|6|7|2G|8|@$9|2H|A|2I|B|C]|$9|2J|A|2K|B|C]|$9|2L|A|2M|B|C]|$9|2N|A|2O|B|C]]|D|@$9|2P|A|2Q|1|2R]]|E|$]]|$1|16|3|17|5|6|7|2S|8|@]|D|@]|E|$]]|$1|18|3|-4|5|6|7|2T|8|@]|D|@]|E|$]]]|19|$1A|$5|1B|1C|1D|E|$1E|1F]]]]

<code>const</code> may be just the implementation you are looking for in conjunction with other functions. Here is an example I discovered.

Say we want to rewrite a structure of 2-tuples to another structure of 2-tuples. I might express this as so:

<pre><code>((a,b),(c,d)) ⇒ (a,(c,(5,a)))
</code></pre>

I can give a straight-forward definition with pattern matching:

<pre><code>f ((a,b),(c,d)) = (a,(c,(5,a)))
</code></pre>

What if I want a pointless (tacit) solution for these kind of rewrites? Some thinking and fiddling later, the answer is that we can express any rewrites with <code>(&amp;&amp;&amp;), const, (.), fst, snd</code>. Note that <code>(&amp;&amp;&amp;)</code> is from <code>Control.Arrow</code>.

The solution of the example using these functions is:

<pre><code>(fst.fst &amp;&amp;&amp; (fst.snd &amp;&amp;&amp; (const 5 &amp;&amp;&amp; fst.fst)))
</code></pre>

Note the similarity with <code>(a,(c,(5,a)))</code>. What if we replace <code>&amp;&amp;&amp;</code> with <code>,</code>? Then it reads:

<pre><code>(fst.fst, (fst.snd, (const 5, fst.fst)))
</code></pre>

Notice how <code>a</code> is the first element of the first element, and that is what <code>fst.fst</code> projects. Notice how <code>c</code> is the first element of the second element, and that is what <code>fst.snd</code> projects. That is, variables become the path to their source.

<code>const</code> allows us to introduce constants. Interesting how the name lines up with the meaning!

I then generalised this idea with Applicative so that you can write any function in a pointless style (so long as you have case analysis available as functions, such as <code>maybe</code>, <code>either</code>, <code>bool</code>). Again, <code>const</code> plays the role of introducing constants. You can see this work in the <a href="http://hackage.haskell.org/package/data-function-tacit-0.1.0.0/docs/Data-Function-Tacit.html" rel="nofollow">Data.Function.Tacit</a> package.

When you start abstractly, at the goal, and then work towards an implementation, you can be surprised by the answers. That is to say, any one function may be as mysterious as any one cog in a machine. If you pull back to bring the whole machine into view, however, you can understand the context in which that cog is necessary.

blocks|key|783347|text|假设您想创建一个等于字符串长度的Nothings列表。当const返回其第一个参数时，无论第二个参数是什么，您都可以这样做：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|783348|listOfNothings+::+String+->+[Maybe+Char]
listOfNothings+=+(map+.+const)+Nothing|code-block|syntax|javascript|783349|或者，更明确地说：|783350|listOfNothing+st+=+map+(const+Nothing)+st|783351|entityMap^0|G|8|S|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

Say you want to create a list of <code>Nothings</code> equal to the length of a string. As <code>const</code> returns its first argument, no matter the second, you can do:

<pre><code>listOfNothings :: String -&gt; [Maybe Char]
listOfNothings = (map . const) Nothing
</code></pre>

or, more explicitly:

<pre><code>listOfNothing st = map (const Nothing) st
</code></pre>

blocks|key|567270|text|假设你想轮换一个列表。在Haskell中这是一种惯用的方式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|567271|rotate+::+Int+->+[a]+->+[a]++rotate+_+[]+=+[]++rotate+n+xs+=+zipWith+const+(drop+n+(cycle+xs))+xs|offset|length|style|CODE|567272|此函数使用函数const压缩两个数组，第一个是无限循环数组，第二个是您开始时使用的数组。|567273|const充当边界检查，并使用原始数组来终止循环数组。|567274|请参阅：Rotate+a+list+in+Haskell|567275|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/16378773/rotate-a-list-in-haskell^0|0|0|2P|0|7|5|0|0|5|0|4|O|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@$D|10|E|11|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|12|8|@$D|13|E|14|F|G]]|9|@]|A|$]]|$1|L|3|M|5|6|7|15|8|@]|9|@$D|16|E|17|1|18]]|A|$]]|$1|N|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|U]]]]

Say you want to rotate a list. This is an idiomatic way to do so in Haskell:

<code>rotate :: Int -&gt; [a] -&gt; [a]
 rotate _ [] = []
 rotate n xs = zipWith const (drop n (cycle xs)) xs</code>

This function zips two arrays with the function <code>const</code>, the first being an infinite cyclic array, the second being the array you started with.

<code>const</code> acts as the bounds check, and uses the original array to terminate the cyclic array.

See: <a href="https://stackoverflow.com/questions/16378773/rotate-a-list-in-haskell">Rotate a list in Haskell</a>

Looking through the Haskell Prelude, I <a href="http://hackage.haskell.org/package/base-4.9.0.0/docs/src/GHC.Base.html#const" rel="noreferrer">see a function</a> <code>const</code>:

<pre><code>const x _ = x
</code></pre>

I can't seem to find anything relevant regarding this function.

What's the point? Can anyone give an example of where this function might be used?

What's the point of 'const' in the Haskell Prelude?

翻阅哈斯克尔的前奏曲，I  constconst x _ = x我似乎找不到任何与此函数相关的东西。这有什么意义呢？有没有人能举个例子说明这个函数可能用在什么地方？

问“哈斯克尔序曲”中“const”的意思是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问“哈斯克尔序曲”中“const”的意思是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问“哈斯克尔序曲”中“const”的意思是什么？
EN