blocks|key|624077|text|(a+->+b)+->+(a,+a)+->+(b,+b)是您所需要的类型，Searching+at+Hoogle没有给出精确的匹配，但是您可以很容易地自己完成：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|624078|mapTuple+::+(a+->+b)+->+(a,+a)+->+(b,+b)
mapTuple+f+(a1,+a2)+=+(f+a1,+f+a2)|code-block|syntax|javascript|624079|请注意，您必须为3元组、4元组等定义一个新函数-尽管这样的需要可能是一个迹象，表明您没有像预期的那样使用元组:一般来说，元组包含不同类型的值，因此想要将一个函数应用于所有值并不是很常见。|624080|entityMap|0|LINK|mutability|MUTABLE|url|http://www.haskell.org/hoogle/?hoogle=%2528a%2520-%253E%2520b%2529%2520-%253E%2520%2528a,%2520a%2529%2520-%253E%2520%2528b,%2520b%2529^0|0|S|11|J|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|11|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

<a href="http://www.haskell.org/hoogle/?hoogle=%28a%20-%3E%20b%29%20-%3E%20%28a,%20a%29%20-%3E%20%28b,%20b%29" rel="noreferrer">Searching at Hoogle</a> gives no exact matches for <code>(a -&gt; b) -&gt; (a, a) -&gt; (b, b)</code>, which is the type you require, but it is pretty easy to do yourself:

<pre><code>mapTuple :: (a -&gt; b) -&gt; (a, a) -&gt; (b, b)
mapTuple f (a1, a2) = (f a1, f a2)
</code></pre>

Note, you will have to define a new function for 3-tuples, 4-tuples etc - although such a need might be a sign, that you are not using tuples like they were intended: In general, tuples hold values of different types, so wanting to apply a single function to all values is not very common.

blocks|key|408943|text|这里有一个相当简短的无点解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|408944|import+Control.Monad+(join)
import+Control.Arrow+((***))

mapTuple+=+join+(***)|code-block|syntax|javascript|408945|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a rather short point-free solution:

<pre><code>import Control.Monad (join)
import Control.Arrow ((***))

mapTuple = join (***)
</code></pre>

blocks|key|408785|text|您可以使用Bifunctor|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|408786|import+Control.Monad++(join)
import+Data.Bifunctor+(bimap)

join+bimap+(2*)+(1,2)|code-block|syntax|javascript|408787|这不仅适用于配对，还适用于许多其他类型，例如Either。|408788|从4.8版开始，base中就包含了Bifunctor。以前它是由bifunctors包提供的。|408789|entityMap|0|LINK|mutability|MUTABLE|url|https://hackage.haskell.org/package/base-4.8.2.0/docs/Data-Bifunctor.html|1|http://hackage.haskell.org/package/bifunctors-4.1.1/docs/Data-Bifunctor.html^0|5|9|0|0|M|6|0|H|9|8|4|0|W|A|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$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|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@$9|18|A|19|1|1A]|$9|1B|A|1C|1|1D]]|E|$]]|$1|O|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]|W|$5|R|S|T|E|$U|X]]]]

You could use <code>Bifunctor</code>:

<pre><code>import Control.Monad (join)
import Data.Bifunctor (bimap)

join bimap (2*) (1,2)
</code></pre>

This works not only for pairs, but for a number of other types as well, e.g. for <code>Either</code>.

<code>Bifunctor</code> is in <a href="https://hackage.haskell.org/package/base-4.8.2.0/docs/Data-Bifunctor.html" rel="noreferrer">base</a> as of version 4.8. Previously it was provided by the <a href="http://hackage.haskell.org/package/bifunctors-4.1.1/docs/Data-Bifunctor.html" rel="noreferrer">bifunctors</a> package.

blocks|key|408714|text|您可以使用模块Control.Arrow中的arrows来组合处理元组的函数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|408715|Prelude+Control.Arrow>+let+f+=+(*2)+***+(*2)
Prelude+Control.Arrow>+f+(1,2)
(2,4)
Prelude+Control.Arrow>+let+f'+=+(*2)+***+(*3)
Prelude+Control.Arrow>+f+(2,2)
(4,4)
Prelude+Control.Arrow>+f'+(2,2)
(4,6)|code-block|syntax|javascript|408716|然后你的mapTuple就变成了|408717|mapTuple+f+=+f+***+f|408718|如果在你的问题中你要求一个函数映射到任意大小的元组上，那么恐怕你不能这样做，因为它们会有不同的类型(例如，元组类型(a,b)和(a,b,c)是完全不同且不相关的)。|408719|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikibooks.org/wiki/Haskell/Understanding_arrows^0|7|D|M|6|0|0|0|0|0|1L|5|1R|7|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]]|E|$]]|$1|F|3|G|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|15|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

You can use <a href="http://en.wikibooks.org/wiki/Haskell/Understanding_arrows" rel="noreferrer">arrows</a> from module <code>Control.Arrow</code> to compose functions that work on tuples.

<pre><code>Prelude Control.Arrow&gt; let f = (*2) *** (*2)
Prelude Control.Arrow&gt; f (1,2)
(2,4)
Prelude Control.Arrow&gt; let f' = (*2) *** (*3)
Prelude Control.Arrow&gt; f (2,2)
(4,4)
Prelude Control.Arrow&gt; f' (2,2)
(4,6)
</code></pre>

Your mapTuple then becomes

<pre><code>mapTuple f = f *** f
</code></pre>

If with your question you asked for a function that maps over tuples of arbitrary arity, then I'm afraid you can't because they would have different types (e.g. the tuple types <code>(a,b)</code> and <code>(a,b,c)</code> are totally different and unrelated).

blocks|key|409344|text|您还可以使用lens来映射元组：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|409345|import+Control.Lens
mapPair+=+over+both|code-block|syntax|javascript|409346|或者您可以映射到最多包含10个元素的元组：|409347|mapNtuple+f+=+traverseOf+each+(return+.+f)|409348|entityMap|0|LINK|mutability|MUTABLE|url|http://hackage.haskell.org/package/lens^0|6|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

You can also use <a href="http://hackage.haskell.org/package/lens">lens</a> to map tuples:

<pre><code>import Control.Lens
mapPair = over both
</code></pre>

Or you can map over tuples with upto 10 elements:

<pre><code>mapNtuple f = traverseOf each (return . f)
</code></pre>

blocks|key|409180|text|为了给这个五颜六色的集合添加另一个解决方案...您还可以使用Scrap-Your-Boilerplate+generic+programming在任意n元组上进行映射。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|409181|import+Data.Data
import+Data.Generics.Aliases

double+::+Int+->+Int
double+=+(*2)

tuple+::+(Int,+Int,+Int,+Int)
tuple+=+gmapT+(mkT+double)+(1,2,3,4)|code-block|syntax|javascript|409182|请注意，显式类型注释很重要，因为SYB按类型选择字段。例如，如果一个元组元素的类型是Float，那么它就不会再加倍了。|style|CODE|409183|entityMap|0|LINK|mutability|MUTABLE|url|http://www.haskell.org/haskellwiki/Scrap_your_boilerplate^0|U|16|0|0|0|16|5|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$A|10|B|11|K|L]]|9|@]|C|$]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

To add another solution to this colourful set... You can also map over arbitrary n-tuples using <a href="http://www.haskell.org/haskellwiki/Scrap_your_boilerplate" rel="nofollow noreferrer">Scrap-Your-Boilerplate generic programming</a>. For example:

<pre><code>import Data.Data
import Data.Generics.Aliases

double :: Int -&gt; Int
double = (*2)

tuple :: (Int, Int, Int, Int)
tuple = gmapT (mkT double) (1,2,3,4)
</code></pre>

Note that the explicit type annotations are important, as SYB selects the fields by type. If one makes one tuple element type <code>Float</code>, for example, it wouldn't be doubled anymore.

blocks|key|624332|text|下面是另一种方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|624333|mapPair+::+(a+->+b)+->+(a,+a)+->+(b,+b)+--+this+is+the+inferred+type
mapPair+f+=+uncurry+((,)+`on`+f)|code-block|syntax|javascript|624334|您需要为on函数导入Data.Function。|offset|length|style|CODE|624335|entityMap^0|0|0|4|2|A|D|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

Here is another way:

<pre><code>mapPair :: (a -&gt; b) -&gt; (a, a) -&gt; (b, b) -- this is the inferred type
mapPair f = uncurry ((,) `on` f)
</code></pre>

You need <code>Data.Function</code> imported for <code>on</code> function.

blocks|key|623791|text|是的，对于两个项目的元组，您可以使用first和second来映射元组的内容(不用担心类型签名；在这种情况下，a+b+c可以读取为b+->+c+)。对于较大的元组，您应该考虑使用数据结构和镜头。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|623792|entityMap|0|LINK|mutability|MUTABLE|url|http://hackage.haskell.org/packages/archive/base/latest/doc/html/Control-Arrow.html#v:first|1|http://hackage.haskell.org/packages/archive/base/latest/doc/html/Control-Arrow.html#v:second^0|I|5|O|6|1J|5|1T|6|I|5|0|O|6|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@$9|Y|A|Z|1|10]|$9|11|A|12|1|13]]|E|$]]|$1|F|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]|N|$5|I|J|K|E|$L|O]]]]

Yes, for tuples of 2 items, you can use <a href="http://hackage.haskell.org/packages/archive/base/latest/doc/html/Control-Arrow.html#v:first" rel="noreferrer"><code>first</code></a> and <a href="http://hackage.haskell.org/packages/archive/base/latest/doc/html/Control-Arrow.html#v:second" rel="noreferrer"><code>second</code></a> to map the contents of a tuple (Don't worry about the type signature; <code>a b c</code> can be read as <code>b -&gt; c</code> in this situation). For larger tuples, you should consider using a data structure and lenses instead.

blocks|key|624471|text|extra包在Data.Tuple.Extra模块中提供了both函数。从文档中：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|624472|Apply+a+single+function+to+both+components+of+a+pair.

>+both+succ+(1,2)+==+(2,3)

both+::+(a+->+b)+->+(a,+a)+->+(b,+b)|code-block|syntax|javascript|624473|entityMap|0|LINK|mutability|MUTABLE|url|https://hackage.haskell.org/package/extra|1|https://hackage.haskell.org/package/extra-0.8/docs/Data-Tuple-Extra.html|2|https://hackage.haskell.org/package/extra-0.8/docs/Data-Tuple-Extra.html#v:both^0|T|4|0|5|0|7|G|1|T|4|2|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]|$9|12|A|13|1|14]|$9|15|A|16|1|17]]|E|$]]|$1|F|3|G|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]|S|$5|N|O|P|E|$Q|T]]|U|$5|N|O|P|E|$Q|V]]]]

The <a href="https://hackage.haskell.org/package/extra">extra</a> package provides the <a href="https://hackage.haskell.org/package/extra-0.8/docs/Data-Tuple-Extra.html#v:both"><code>both</code></a> function in the <a href="https://hackage.haskell.org/package/extra-0.8/docs/Data-Tuple-Extra.html">Data.Tuple.Extra</a> module. From the docs:

<pre><code>Apply a single function to both components of a pair.

&gt; both succ (1,2) == (2,3)

both :: (a -&gt; b) -&gt; (a, a) -&gt; (b, b)
</code></pre>

blocks|key|624378|text|我刚刚在Hackage中添加了一个包tuples-homogenous-h98来解决这个问题。它为元组添加了newtype包装器，并为它们定义了Functor、Applicative、Foldable和Traversable实例。使用该包，您可以执行以下操作：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|624379|untuple2+.+fmap+(2+*)+.+Tuple2+$+(1,+2)|code-block|syntax|javascript|624380|或者像这样的zip元组：|624381|Tuple2+((%2B+1),+(*2))+<*>+Tuple2+(1,+10)|624382|entityMap|0|LINK|mutability|MUTABLE|url|http://hackage.haskell.org/package/tuples-homogenous-h98^0|1I|7|20|7|28|B|2K|8|2T|B|I|L|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@$9|17|A|18|1|19]]|E|$]]|$1|F|3|G|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1B|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1C|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

I just added a package <a href="http://hackage.haskell.org/package/tuples-homogenous-h98" rel="nofollow">tuples-homogenous-h98</a> to Hackage that solves this problem. It adds <code>newtype</code> wrappers for tuples and defines <code>Functor</code>, <code>Applicative</code>, <code>Foldable</code> and <code>Traversable</code> instances for them. Using the package you can do things like:

<pre><code>untuple2 . fmap (2 *) . Tuple2 $ (1, 2)
</code></pre>

or zip tuples like:

<pre><code>Tuple2 ((+ 1), (*2)) &lt;*&gt; Tuple2 (1, 10)
</code></pre>

blocks|key|409478|text|uniplate包在Data.Generics.Uniplate.Data模块中提供了descend函数。此函数将在所有类型匹配的地方应用该函数，因此可以应用于列表、元组、或大多数其他数据类型。下面是一些例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|409479|descend+(\x+->+2*x)+(1,2)+==+(2,4)
descend+(\x+->+2*x)+(1,"test",Just+2)+==+(2,"test",Just+4)
descend+(\x+->+2*x)+(1,2,3,4,5)+==+(2,4,6,8,10)
descend+(\x+->+2*x)+[1,2,3,4,5]+==+[2,4,6,8,10]|code-block|syntax|javascript|409480|entityMap|0|LINK|mutability|MUTABLE|url|https://hackage.haskell.org/package/uniplate|1|https://hackage.haskell.org/package/uniplate-1.6.12/docs/Data-Generics-Uniplate-Data.html|2|https://hackage.haskell.org/package/uniplate-1.6.12/docs/Data-Generics-Uniplate-Operations.html#v:descend^0|0|8|0|A|R|1|17|7|2|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]|$A|Y|B|Z|1|10]|$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]|Q|$5|L|M|N|C|$O|R]]|S|$5|L|M|N|C|$O|T]]]]

The <a href="https://hackage.haskell.org/package/uniplate" rel="nofollow">uniplate</a> package provides the <a href="https://hackage.haskell.org/package/uniplate-1.6.12/docs/Data-Generics-Uniplate-Operations.html#v:descend" rel="nofollow">descend</a> function in the <a href="https://hackage.haskell.org/package/uniplate-1.6.12/docs/Data-Generics-Uniplate-Data.html" rel="nofollow">Data.Generics.Uniplate.Data</a> module. This function will apply the function everywhere the types match, so can be applied to lists, tuples, Either, or most other data types. Some examples:

<pre><code>descend (\x -&gt; 2*x) (1,2) == (2,4)
descend (\x -&gt; 2*x) (1,"test",Just 2) == (2,"test",Just 4)
descend (\x -&gt; 2*x) (1,2,3,4,5) == (2,4,6,8,10)
descend (\x -&gt; 2*x) [1,2,3,4,5] == [2,4,6,8,10]
</code></pre>

blocks|key|408538|text|是的，你会这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|408539|map+(\x+->+(fst+x+*2,+snd+x+*2))+[(1,2)]|code-block|syntax|javascript|408540|fst获取元组中的第一个数据条目，snd获取第二个数据条目；因此，这行代码说：“获取一个元组，并返回另一个元组，其中第一个和第二个条目是前一个的两倍。”|offset|length|style|CODE|408541|entityMap^0|0|0|0|3|H|3|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

Yes, you would do:

<pre><code>map (\x -&gt; (fst x *2, snd x *2)) [(1,2)]
</code></pre>

<code>fst</code> grabs the first data entry in a tuple, and <code>snd</code> grabs the second; so, the line of code says "take a tuple, and return another tuple with the first and second items double the previous."

In Haskell, I can easily map a list:

<pre><code>map (\x -&gt; 2*x) [1,2]
</code></pre>

gives me <code>[2,4]</code>. Is there any "mapTuple" function which would work like that?

<pre><code>mapTuple (\x -&gt; 2*x) (1,2)
</code></pre>

with the result being <code>(2,4)</code>.

Haskell: how to map a tuple?

数据结构

在Haskell中，我可以很容易地映射一个列表：map (\x -> 2*x) [1,2]给了我[2,4]。有没有像这样工作的"mapTuple“函数？mapTuple (\x -> 2*x) (1,2)结果是(2,4)。

问Haskell:如何映射元组？
EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Haskell:如何映射元组？EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Haskell:如何映射元组？
EN