Haskell:如何映射元组？

Question

在Haskell中,我可以轻松地映射列表:

map (\x -> 2*x) [1,2]

给了我[2,4].是否有任何"mapTuple"功能可以这样工作？

mapTuple (\x -> 2*x) (1,2)

结果是(2,4).

Answer 1

这是一个相当短的无点解决方案:

import Control.Monad (join)
import Control.Arrow ((***))

mapTuple = join (***)

Answer 2

在Hoogle搜索没有提供完全匹配(a -> b) -> (a, a) -> (b, b),这是您需要的类型,但您自己很容易做到:

mapTuple :: (a -> b) -> (a, a) -> (b, b)
mapTuple f (a1, a2) = (f a1, f a2)

注意,你必须为3元组,4元组等定义一个新函数 - 虽然这样的需要可能是一个标志,你没有像他们想要的那样使用元组:通常,元组保存不同类型的值,所以想要将单个函数应用于所有值并不常见.

Answer 3

你可以使用Bifunctor:

import Control.Monad  (join)
import Data.Bifunctor (bimap)

join bimap (2*) (1,2)

这不仅适用于对,也适用于许多其他类型,例如Either.

Bifunctor在4.8版本的基础上.以前它是由bifunctors包提供的.

Answer 4

您可以使用模块中的箭头Control.Arrow来组合对元组起作用的函数.

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)

然后你的mapTuple就变成了

mapTuple f = f *** f

如果你的问题是你要求一个映射了任意arity的元组的函数,那么我担心你不能因为它们会有不同的类型(例如元组类型(a,b)并且(a,b,c)完全不同且不相关).

Answer 5

您还可以使用镜头来映射元组:

import Control.Lens
mapPair = over both

或者,您可以使用最多10个元素映射元组:

mapNtuple f = traverseOf each (return . f)

Answer 6

要为这个彩色集添加另一个解决方案......您还可以使用Scrap-Your-Boilerplate泛型编程映射任意n元组.例如:

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)

请注意,显式类型注释很重要,因为SYB按类型选择字段.Float例如,如果一个元组构成一个元组元素类型,它就不会再加倍.

Answer 7

这是另一种方式:

mapPair :: (a -> b) -> (a, a) -> (b, b) -- this is the inferred type
mapPair f = uncurry ((,) `on` f)

您需要Data.Function导入on功能.

Answer 8

是的,对于2个元组的元组,您可以使用first和second映射元组的内容(不要担心类型签名; a b c可以b -> c在这种情况下读取).对于较大的元组,您应该考虑使用数据结构和镜头.

Answer 9

该额外的软件包提供both的函数Data.Tuple.Extra模块.来自文档:

Apply a single function to both components of a pair.

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

both :: (a -> b) -> (a, a) -> (b, b)

Answer 10

您还可以使用Applicatives,它具有额外的好处,使您可以为每个元组元素应用不同的函数:

import Control.Applicative

mapTuple :: (a -> a') -> (b -> b') -> (a, b) -> (a', b')
mapTuple f g = (,) <$>  f . fst <*> g . snd

内联版本:

(\f -> (,) <$>  f . fst <*> f . snd) (*2) (3, 4)

或者使用不同的map函数和没有lambda:

(,) <$> (*2) . fst <*> (*7) . snd $ (3, 4)

其他可能性是使用箭头:

import Control.Arrow

(+2) . fst &&& (+2) . snd $ (2, 3)

Answer 11

我刚刚向 Hackage 添加了一个包tuples-homous-h98来解决这个问题。它为元组添加newtype包装器并为它们定义Functor、Applicative和Foldable实例。Traversable使用该包您可以执行以下操作：

untuple2 . fmap (2 *) . Tuple2 $ (1, 2)

或压缩元组，例如：

Tuple2 ((+ 1), (*2)) <*> Tuple2 (1, 10)