使用以下函数查找元组中的第 n 个元素

Question

“使用带有两个参数的以下函数：

nth :: (a,a,a,a,a) -> Int -> a

其中 Int 值应返回五元素元组的第 Int 个值。”我试过：

nth (a,b,c,d,e) x = (a,b,c,d,e) !! x

但是 GHC 给了我一个错误信息：

file.hs:11:21: error:
* Couldn't match expected type `[a1]'
              with actual type `(a, b, c, d, e)'
* In the first argument of `(!!)', namely `(a, b, c, d, e)'
  In the expression: (a, b, c, d, e) !! x
  In an equation for `nth':
      nth (a, b, c, d, e) x = (a, b, c, d, e) !! x
* Relevant bindings include
    e :: e (bound at file.hs:11:14)
    d :: d (bound at file.hs:11:12)
    c :: c (bound at file.hs:11:10)
    b :: b (bound at file.hs:11:8)
    a :: a (bound at file.hs:11:6)
    nth :: (a, b, c, d, e) -> Int -> a1
      (bound at file.hs:11:1)

我该怎么办？ 我应该如何写这个方程的元组部分？ 提前感谢您的回答！

Answer 1

你不能使用(!!) :: [a] -> Int -> a因为，正如签名所说，它适用于列表，而不是元组。 您可以使用模式匹配并将其实现为：

nth :: (a, a, a, a, a) -> Int -> a
nth (a, _, _, _, _) 0 = a
nth (_, b, _, _, _) 1 = b
nth (_, _, c, _, _) 2 = c
nth (_, _, _, d, _) 3 = d
nth (_, _, _, _, e) 4 = e

有人提议将 3 元组定义为(a, (b, c)) ，因此它是一个递归结构，其中n元组定义为2元组， n-1元组为第二个物品。 但情况并非如此（目前）。

Answer 2

您可以通过将元组的模式匹配与n上的匹配分开来避免现有模式匹配解决方案中的一些重复：

nth :: (a, a, a, a, a) -> Int -> a
nth (a, b, c, d, e) n = case n of
  0 -> a
  1 -> b
  2 -> c
  3 -> d
  4 -> e

您还应该考虑当 n 不在[0, 4]范围内时要发生什么。 正如所写的那样，您将在运行时得到一个非穷尽的模式错误。 返回一个Maybe a或者采用更受约束的类型作为输入会更诚实，比如

data QuintupleIndex = Zero | One | Two | Three | Four

Answer 3

（转自我自己的评论）

实际上，其他答案中没有提到一个简单的解决方法：您只需要更改两个符号：

nth :: (a, a, a, a, a) -> Int -> a
nth (a,b,c,d,e) x = [a,b,c,d,e] !! x

-- or alternatively
nth (a,b,c,d,e) = ([a,b,c,d,e] !!)

仍然需要进行模式匹配来找到第 n 个元素，但现在它在!! .

这是有效的，因为 list 是同构的，这意味着它的所有元素都是相同的类型。 在nth的左侧，您有模式(a,b,c,d,e) ，因此类型推断给出了最一般的约束a :: a, b :: b, ...如错误所示信息。 但是，一旦在右侧看到[a,b,c,d,e] ，它就会为类型推断提供一个线索，即所有a 、 b 、 c 、 d 、 e都是同一类型！ 所以类型推断现在可以确定(a,b,c,d,e) :: (a,a,a,a,a) 。

在 Haskell 中，元组并不意味着是像列表一样使用Int索引的容器类型（与 Python 和其他一些语言中的元组不同），而是更像是每个字段都具有特定含义的struct （将其视为 C 中的struct ） )，如果您确实希望对其进行有效索引，则需要字段选择器而不是自然数：

data Five a = Five { _1 :: a,  _2 :: a,  _3 :: a,  _4 :: a,  _5 :: a }

现在您可以使用_x访问字段，但nth的类型将是：

nth :: Five a -> (Five a -> a) -> a
nth v f = f v

-- or pointfreely:
nth = flip id

（另一个好处是你有一个完整的函数，而不是一个可能会失败模式匹配并引发异常的函数）

请注意，字段选择器是函数而不是自然数 - 如果您正在处理列表索引，那么询问“下一个元素是什么？”是有意义的，但在涉及结构时则不然。

Answer 4

(!!)函数仅适用于列表。

对于元组，至少那些超​​过 2 个元素的元组，访问元素的唯一方法是通过直接模式匹配：

nth :: (a,a,a,a,a) -> Int -> a
nth (a, _, _, _, _) 0 = a
nth (_, a, _, _, _) 1 = a
nth (_, _, a, _, _) 2 = a
nth (_, _, _, a, _) 3 = a
nth (_, _, _, _, a) 4 = a

（注意_ s，它的意思是“我不在乎这个值是什么”。你可以给他们一个名字 - 例如在每一行上匹配(a, b, c, d, e)并有返回值在第一行是a ，在第二行是b ，依此类推。但仅命名您关心的值会减少视觉“噪音”。）

另请注意，如果整数参数是 0-4 以外的任何值，则此函数将因“非穷尽模式”错误而崩溃。 但是在包含 5 个元素的列表上使用(!!)也有类似的缺陷。 您可以轻松地将默认情况添加到最后，尽管在使用完全通用的类型a时这并不容易，因为没有值可以作为调用函数的任何类型的返回值！

Answer 5

使用警卫的简单解决方案如下：

nth :: (a,a,a,a,a) -> Int -> a
nth (a, b, c, d, e) i
  | i == 0    = a
  | i == 1    = b
  | i == 2    = c
  | i == 3    = d
  | otherwise = e