blocks|key|1865100|text|不，你不能。基本的问题是Haskell的语法欺骗了你，让你认为f1和f2的类型比实际更相似。一旦翻译成GHC+Core，它们看起来就更不同了：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1865101|f1+::+forall+a+.+a+->+[a]
f2+::+Int+->+Int|code-block|syntax|javascript|1865102|不仅如此，相应的术语看起来也有很大不同：|1865103|f1+=+Λa+->+λ(x+::+a)+->+[x]
f2+=+λ(x+::+Int)+->+3+*+x|1865104|正如您所看到的，f1和f2实际上具有不同数量的参数，其中f1接受类型和值，而f2只接受一个值。|1865105|在更常见的情况下，当您将f2放入一个期望类型为Int+->+[Int]的函数的上下文中时，GHC会为您将f2应用于必要的类型(即，将f2实例化为特定类型)，一切都会好起来的。例如，如果您有|1865106|g+::+(Int+->+[Int])+->+Bool|1865107|将g应用于f，GHC实际上会将其编译为|1865108|g+(f+@Int)|1865109|但在这里，您需要多态来决定实例化是否发生，这是GHC不支持的(我认为这将是对核心语言的一个相当激进和破坏性的更改)。|1865110|因为类实例、类型族模式和类型族结果不能被量化，所以我非常确信没有任何方法可以得到你想要的结果。|1865111|entityMap^0|V|2|Y|2|0|0|0|0|8|2|B|2|S|2|12|2|0|C|2|N|C|1G|2|1U|2|0|0|1|1|5|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1A|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1L|8|@$9|1M|A|1N|B|C]|$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|H|7|1U|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|1V|8|@$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|C]]|D|@]|E|$]]|$1|W|3|X|5|H|7|20|8|@]|D|@]|E|$I|J]]|$1|Y|3|Z|5|6|7|21|8|@]|D|@]|E|$]]|$1|10|3|11|5|6|7|22|8|@]|D|@]|E|$]]|$1|12|3|-4|5|6|7|23|8|@]|D|@]|E|$]]]|13|$]]

No, you can't. The basic problem is that Haskell's syntax has fooled you into thinking that <code>f1</code>'s and <code>f2</code>'s types are more similar than they really are. Once translated into GHC Core, they look rather more different:

<pre><code>f1 :: forall a . a -&gt; [a]
f2 :: Int -&gt; Int
</code></pre>

Not only this, but the corresponding terms look rather different:

<pre><code>f1 = Λa -&gt; λ(x :: a) -&gt; [x]
f2 = λ(x :: Int) -&gt; 3 * x
</code></pre>

As you can see, <code>f1</code> and <code>f2</code> actually have different numbers of arguments, where <code>f1</code> takes a type and a value, and <code>f2</code> takes just a value.

In more usual circumstances, when you plop <code>f2</code> into a context expecting a function of type, say, <code>Int -&gt; [Int]</code>, GHC will apply <code>f2</code> to the necessary type for you (i.e., instantiate <code>f2</code> to a specific type), and all will be well. For example, if you have

<pre><code>g :: (Int -&gt; [Int]) -&gt; Bool
</code></pre>

and you apply <code>g</code> to <code>f</code>, GHC will actually compile that to

<pre><code>g (f @Int)
</code></pre>

But here you want polymorphism over whether that instantiation happens or not, which GHC doesn't support (I think it would be a rather radical and destructive change to the core language).

Since class instances, type family patterns, and type family results cannot be quantified, I'm pretty confident there is no way whatsoever to get what you want.

blocks|key|1650841|text|这实际上是可能的，如果你不介意添加一个Proxy参数，使用my+answer+to+a+similar+question+here的一个变体。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1650842|我对这个答案的大部分解释都在这里，但我们需要通过添加更多的帮助器类型类(我在这里称为List和Both+)来稍微扩展一下：|1650843|{-#+LANGUAGE+RankNTypes++++++++++++#-}
{-#+LANGUAGE+MultiParamTypeClasses+#-}
{-#+LANGUAGE+TypeFamilies++++++++++#-}
{-#+LANGUAGE+FlexibleInstances+++++#-}
{-#+LANGUAGE+ConstraintKinds+++++++#-}

import+++++++++++Data.Proxy

f1+::+a+->+[a]
f1+x+=+[x]

x1+::+Int
x1+=+42

c1+::+Char
c1+=+'c'

f2+::+Int+->+Int
f2+x+=+3+*+x

x2+::+Int
x2+=+5

class+b+~+[a]+=>+List+a+b
instance+List+a+[a]

class+(a+~+b,+b+~+c)+=>+Both+a+b+c
instance+Both+a+a+a

g+::+(c+a+r1,+c+b+r2)+=>
++++++Proxy+c+->+(forall+x+r.+c+x+r+=>+x+->+r)+->+a+->+b+->+(r1,+r2)
g+_+f+x+y+=+(f+x,+f+y)|code-block|syntax|javascript|1650844|这让我们可以做|1650845|ghci>+g+(Proxy+::+Proxy+List)+f1+x1+c1
([42],"c")
ghci>+g+(Proxy+::+Proxy+(Both+Int))+f2+x1+x2
(126,15)|1650846|List和Both不是最好的名字(尤其是List)，所以如果你真的使用它，你可能会想出更好的名字(尽管我不确定我建议在生产代码中做这种类型的把戏，除非你有一个非常好的理由)。|1650847|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/31223058/2476735^0|J|5|T|10|0|0|16|4|1B|4|0|0|0|0|0|4|5|4|K|4|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]]|E|$]]|$1|F|3|G|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1B|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1C|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1D|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]]]

This is actually possible, if you don't mind adding a <code>Proxy</code> argument, using a variation on <a href="https://stackoverflow.com/a/31223058/2476735">my answer to a similar question here</a>.

Most of my explanation from that answer holds here, but we need to expand on it slightly by adding a couple more helper type classes (what I'm calling <code>List</code> and <code>Both</code> here):

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

import Data.Proxy

f1 :: a -&gt; [a]
f1 x = [x]

x1 :: Int
x1 = 42

c1 :: Char
c1 = 'c'

f2 :: Int -&gt; Int
f2 x = 3 * x

x2 :: Int
x2 = 5

class b ~ [a] =&gt; List a b
instance List a [a]

class (a ~ b, b ~ c) =&gt; Both a b c
instance Both a a a

g :: (c a r1, c b r2) =&gt;
 Proxy c -&gt; (forall x r. c x r =&gt; x -&gt; r) -&gt; a -&gt; b -&gt; (r1, r2)
g _ f x y = (f x, f y)
</code></pre>

This allows us to do

<pre><code>ghci&gt; g (Proxy :: Proxy List) f1 x1 c1
([42],"c")
ghci&gt; g (Proxy :: Proxy (Both Int)) f2 x1 x2
(126,15)
</code></pre>

<code>List</code> and <code>Both</code> are not the best names (especially <code>List</code>), so you might want to come up with better ones if you do use this (although I'm not sure I would suggest doing this sort of type trickery in production code anyway, unless you have a really good reason).

Can I, and if so, how do I, write the type signature for a function:

<pre><code>g f x y = (f x, f y)
</code></pre>

Such that given:

<pre><code>f1 :: a -&gt; [a]
f1 x = [x]

x1 :: Int
x1 = 42

c1 :: Char
c1 = 'c'

f2 :: Int -&gt; Int
f2 x = 3 * x

x2 :: Int
x2 = 5
</code></pre>

Such that:

<pre><code>g f1 x1 c1 == ([42], ['c']) :: ([Int], [Char])
g f2 x1 x2 == (126, 15) :: (Int, Int)
</code></pre>

Type signature for function with possibly polymorphic arguments

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我可以为函数编写类型签名吗?如果可以，我该如何编写：g f x y = (f x, f y)使得给定：f1 :: a -> [a]f1 x = [x]x1 :: Intx1 = 42c1 :: Charc1 = 'c'f2 :: Int -> Intf2 x = 3 * xx2 :: Intx2 = 5这样：g f1 ...

问可能具有多态参数的函数的类型签名
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问可能具有多态参数的函数的类型签名EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问可能具有多态参数的函数的类型签名
EN