如何限制元组？

Question

我认为Haskell中的元组就像

  tuple :: (a,b)

这意味着a和b可以是相同类型，也可以是不同类型

所以，如果我定义一个函数而不给它类型，那么当我写ghci中的t函数时，我可能得到（t，t1）或一些不同的类型。 因此，如果不在功能中定义它，可能只获得相同的类型。 我听说不允许使用haskell

所以我不能写一些像

这样的功能

  function [(x,x)]=[(x,x,x)]

获取

  :t function
     function :: [(a,a)]->[(a,a,a)]

这是我想要做的练习，这个练习要我编写一个函数而不定义类型。例如获取

  Bool->(Char,Bool) 

当我给出

  :t function

在ghci。我应该写 -

  function True=('A',True)

我不允许定义函数的类型部分 所以我不能写

  function::(Eq a)=>[(a,a)]->[(a,a,a)]

或类似的东西

Answer 1

您可以使用Prelude中的函数asTypeOf来限制元组的第二个组件的类型与第一个组件的类型相同。例如，在GHCi中：

> let f (x, y) = (x, y `asTypeOf` x, x)

> :t f
f :: (t, t) -> (t, t, t)

Answer 2

您可以通过写出所需的类型来愉快地将类型限制为等效。

type Pair a = (a,a)
type Triple a = (a,a,a)

然后：

fn :: [Pair a] -> [Triple a]

将强制执行您想要的约束。

Answer 3

唐可以使用type。或者，如果您不想打扰它（也许您只需要一个函数），您可以指定函数的类型签名，如下所示：

function :: [(a,a)] -> [(a,a,a)]
function xs = map (\(a, b) -> (a, b, a)) xs -- just an example

Answer 4

我猜你正在寻找的是asTypeOf功能。使用它可以将某个值的类型限制为与函数定义中的另一个值相同。 E.g：

Prelude> :t \(a, b) -> (a, b `asTypeOf` a)
\(a, b) -> (a, b `asTypeOf` a) :: (t, t) -> (t, t)

Answer 5

以下内容无需asTypeOf：

trans (a,b) = case [a,b] of _ -> (a,b,a)
function xs = map trans xs

Answer 6

好的，如果我理解正确的话，你所遇到的问题实际上与类型无关。你的定义，

function [(x,x)]=[(x,x,x)]

将无法正常工作，因为您实际上是在说“如果参数为 function是一个包含一个元素的列表，该元素是一个元组， 然后调用然后将x绑定到元组的第一部分，也绑定 x到元组的第二部分“。 您不能一次将符号绑定到两个表达式。

如果您真正想要的是确保元组的两个部分 是相同的，那么你可以做这样的事情：

function [(x,y)] = if x == y then [(x,x,x)] else error "mismatch"

或者这个：

function2 [(x,y)] | x == y = [(x,x,x)]

...但是当元组的各个部分不匹配时，这将会失败。

现在我怀疑你真正想要的是处理超过的列表 一个要素。所以你可能想做类似的事情：

function3 xs = map f xs
  where f (x, y) = if x == y then [(x,x,x)] else error "mismatch"

任何这些功能都将具有您想要的类型Eq t => [(t, t)] -> [(t, t, t)]，而无需您指定。