blocks|key|760586|text|我不认为您的第一个示例是非常Haskell-y的，因为您重载了相同的名称来做两个非常不同的事情。在Haskell中，当您将一个函数映射到某个容器上时，您希望得到相同的容器类型。事实上，这在Haskell中非常常见，以至于有一个类型类，Functor，它封装了这个模式。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|760587|Haskell中的所有形式的重载都归结为使用类型类，虽然您可以使用这些类来实现类似的功能，但它将是非常人为的，并且与仅使用仅做您想要的一件事的普通函数相比没有多大用处。|760588|Prelude>+import+qualified+Data.Map+as+M
Prelude+Data.Map>+let+m+=+M.fromList+[(2,+'a'),+(6,+'b')]
Prelude+Data.Map>+M.map+show+$+M.mapKeys+(%2B1)+m
fromList+[(3,"'a'"),(7,"'b'")]
Prelude+Data.Map>+M.keys+m
[2,6]|code-block|syntax|javascript|760589|我认为您的第二个示例与Haskell更相关，因为它更多地是关于根据包含的类型选择最有效的数据结构实现，我怀疑使用type+families应该不会太难，但我对这些不太熟悉，所以我会让其他人尝试回答这一部分。|760590|entityMap|0|LINK|mutability|MUTABLE|url|http://www.haskell.org/haskellwiki/GHC/Type_families^0|39|7|0|0|0|1K|D|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|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|D|@$9|12|A|13|1|14]]|E|$]]|$1|O|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

I don't think your first example is very Haskell-y, as you're overloading the same name to do two very different things. In Haskell, when you map a function over some container, you expect to get the same container type back. In fact, this is so common in Haskell that there is a type class, <code>Functor</code> which encapsulates this pattern.

All forms of overloading in Haskell boil down to using type classes, and while you could use those to achieve something similar, it would be very contrived and not very useful over just using plain functions that do just the one thing you want.

<pre><code>Prelude&gt; import qualified Data.Map as M
Prelude Data.Map&gt; let m = M.fromList [(2, 'a'), (6, 'b')]
Prelude Data.Map&gt; M.map show $ M.mapKeys (+1) m
fromList [(3,"'a'"),(7,"'b'")]
Prelude Data.Map&gt; M.keys m
[2,6]
</code></pre>

I think your second example is more relevant to Haskell, as it's more about picking the most efficient implementation of a data structure based on the contained type, and I suspect this shouldn't be too difficult to do using <a href="http://www.haskell.org/haskellwiki/GHC/Type_families" rel="noreferrer">type families</a>, but I'm not too familiar with those, so I'll let someone else try to answer that part.

blocks|key|760649|text|我非常同意hammar的观点，但这里有一种方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|760650|{-#+LANGUAGE+MultiParamTypeClasses,+TypeFamilies,+FlexibleInstances+#-}

import+Prelude+hiding+(map)

import+qualified+Data.Map+as+M
import+qualified+Data.IntSet+as+I
import+qualified+Data.Set+as+S

type+family+Elem+c+::+*
type+instance+Elem+(M.Map+k+v)+=+(k,+v)
type+instance+Elem+I.IntSet+=+Int
type+instance+Elem+(S.Set+a)+=+a

class+Map+c+o+where
++type+Result+c+o+::+*
++map+::+(Elem+c+->+o)+->+c+->+Result+c+o

instance+Map+I.IntSet+Int+where
++type+Result+I.IntSet+Int+=+I.IntSet
++map+=+I.map

instance+Map+I.IntSet+String+where
++type+Result+I.IntSet+String+=+S.Set+String
++map+f+=+S.fromList+.+fmap+f+.+I.toList

instance+(Ord+k,+Ord+k1)+=>+Map+(M.Map+k+v)+(k1,+v1)+where
++type+Result+(M.Map+k+v)+(k1,+v1)+=+M.Map+k1+v1
++map+f+=+M.fromList+.+fmap+f+.+M.toList

instance+(Ord+k)+=>+Map+(M.Map+k+v)+Int+where
++type+Result+(M.Map+k+v)+Int+=+[Int]
++map+f+=+fmap+f+.+M.toList|code-block|syntax|javascript|760651|这就是它的实际作用：|760652|*Main>+map+fst+(M.fromList+[(2::Int,+'a'),+(6,+'b')])
[2,6]
*Main>+map+(\(k,+v)+->+(k+%2B+1,+show+v))+(M.fromList+[(2,+'a'),+(6,+'b')])
fromList+[(3,"'a'"),(7,"'b'")]
*Main>+:t+it
it+::+M.Map+Integer+[Char]|760653|理想情况下，您会希望这样做：|760654|instance+(Ord+k)+=>+Map+(M.Map+k+v)+a+where
++type+Result+(M.Map+k+v)+a+=+[a]
++map+f+=+fmap+f+.+M.toList|760655|但该实例与pairs的实例冲突。因此，没有好的方法为每个其他类型提供一个实例。|760656|entityMap^0|0|0|0|0|0|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|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I very much agree with hammar, but here's a way to do it, sort of:

<pre><code>{-# LANGUAGE MultiParamTypeClasses, TypeFamilies, FlexibleInstances #-}

import Prelude hiding (map)

import qualified Data.Map as M
import qualified Data.IntSet as I
import qualified Data.Set as S

type family Elem c :: *
type instance Elem (M.Map k v) = (k, v)
type instance Elem I.IntSet = Int
type instance Elem (S.Set a) = a

class Map c o where
 type Result c o :: *
 map :: (Elem c -&gt; o) -&gt; c -&gt; Result c o

instance Map I.IntSet Int where
 type Result I.IntSet Int = I.IntSet
 map = I.map

instance Map I.IntSet String where
 type Result I.IntSet String = S.Set String
 map f = S.fromList . fmap f . I.toList

instance (Ord k, Ord k1) =&gt; Map (M.Map k v) (k1, v1) where
 type Result (M.Map k v) (k1, v1) = M.Map k1 v1
 map f = M.fromList . fmap f . M.toList

instance (Ord k) =&gt; Map (M.Map k v) Int where
 type Result (M.Map k v) Int = [Int]
 map f = fmap f . M.toList
</code></pre>

Here it is in action:

<pre><code>*Main&gt; map fst (M.fromList [(2::Int, 'a'), (6, 'b')])
[2,6]
*Main&gt; map (\(k, v) -&gt; (k + 1, show v)) (M.fromList [(2, 'a'), (6, 'b')])
fromList [(3,"'a'"),(7,"'b'")]
*Main&gt; :t it
it :: M.Map Integer [Char]
</code></pre>

Ideally you'd want to do this:

<pre><code>instance (Ord k) =&gt; Map (M.Map k v) a where
 type Result (M.Map k v) a = [a]
 map f = fmap f . M.toList
</code></pre>

But that instance conflicts with the one for pairs. So there's no good way to give an instance for every other type.

blocks|key|544135|text|补充一下hammar:我认为第二个例子是不可能的，因为有隐式的类型转换。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|544136|为了便于讨论，忽略这一点，类型签名是什么样子的：|544137|setmap+::+(Set+a,+Set+b)+=>+a+e+->+(e+->+f)+->+b+f+|code-block|syntax|javascript|544138|所以，是的，这是可以想象的，但前提是可能需要指定返回类型。|544139|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Adding to hammar: I think the second example is not possible as it stands, because there are implicit type conversions.

Ignoring that for the sake of the discussion, how could the type signature look like:

<pre><code>setmap :: (Set a, Set b) =&gt; a e -&gt; (e -&gt; f) -&gt; b f 
</code></pre>

So, yes, this is conceivable, yet with the provision that one may need to specify the return type.

In Scala, the higher order operations on collections always return the best possible type in the context. For example, in case of <code>BitSet</code>, if you map ints to ints you get a <code>BitSet</code>, but if you map ints to strings, you get a general <code>Set</code>. Similarly, if you <code>map</code> a <code>Map</code> with a function that yields a pair, then you get a <code>Map</code> in return. Else you get a simple <code>Iterable</code>. Both the static type and the runtime representation of map's result depend on the result type of the function that's passed to it. 

<pre><code>scala&gt; Map(2 -&gt; 'a', 6 -&gt; 'b') map { case (k, v) =&gt; (k + 1, v.toString) }
res0: scala.collection.immutable.Map[Int,java.lang.String] = Map(3 -&gt; a, 7 -&gt; b)

scala&gt; Map(2 -&gt; 'a', 6 -&gt; 'b') map { _._1 }
res1: scala.collection.immutable.Iterable[Int] = List(2, 6)

scala&gt; import collection.immutable.BitSet
import collection.immutable.BitSet

scala&gt; BitSet(2, 44, 93).map(1 +)
res3: scala.collection.immutable.BitSet = BitSet(3, 45, 94)

scala&gt; BitSet(2, 44, 93).map(_ + "hola")
res4: scala.collection.immutable.Set[String] = Set(2hola, 44hola, 93hola)
</code></pre>

Is it possible to implement the same functionality in Haskell's type system? If yes, how? A Haskell translation of the examples in above code snippet would be much appreciated. :-)

Can this functionality be implemented with Haskell's type system?

数据结构

容器

在Scala中，集合上的高阶操作总是返回上下文中可能的最佳类型。例如，在BitSet的情况下，如果将in映射到in，则会得到一个BitSet，但如果将in映射到字符串，则会得到一个通用的Set。类似地，如果您使用生成一对的函数对Map执行map操作，则会返回一个Map。否则你会得到一个简单的Iterable。map结果...

问这个功能可以用Haskell的类型系统实现吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问这个功能可以用Haskell的类型系统实现吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问这个功能可以用Haskell的类型系统实现吗？
EN