可以使用模式匹配来绑定列表的最后一个元素吗？

Question

由于有一种方法可以通过模式匹配来绑定列表的头和尾，我想知道是否可以使用模式匹配来绑定列表的最后一个元素？

Answer 1

是的，您可以使用 ViewPatterns 扩展。

Prelude> :set -XViewPatterns
Prelude> let f (last -> x) = x*2
Prelude> f [1, 2, 3]
6

请注意，此模式总是会成功，因此您可能需要为列表为空的情况添加一个模式，否则 last 将引发异常。

Prelude> f []
*** Exception: Prelude.last: empty list

另请注意，这只是语法糖。与普通模式匹配不同，这是 O(n)，因为您仍在访问单链表的最后一个元素。如果您需要更有效的访问，请考虑使用不同的数据结构，例如 < code>Data.Sequence，它提供对两端的 O(1) 访问权限。

Answer 2

您可以使用 ViewPatterns 在列表末尾进行模式匹配，所以让我们

{-# LANGUAGE ViewPatterns #-}

使用 reverse 作为 viewFunction，因为它总是成功，所以例如

printLast :: Show a => IO ()
printLast (reverse -> (x:_)) = print x
printLast _ = putStrLn "Sorry, there wasn't a last element to print."

这是安全的从某种意义上说，只要您涵盖了所有可能性，它就不会抛出任何异常。
（例如，您可以重写它以返回 Maybe。）

语法

mainFunction (viewFunction ->pattern) = resultExpression

的语法糖

是mainFunction x = 。 case viewFunction x 的模式 -> resultExpression

所以你可以看到它实际上只是反转列表然后模式匹配它，但感觉更好。
viewFunction 是您喜欢的任何函数。
（扩展的目的之一是让人们能够干净、轻松地使用访问器函数
用于模式匹配，因此他们不必在以下情况下使用其数据类型的底层结构：
在其上定义函数。）

Answer 3

其他答案解释了基于 ViewPatterns 的解决方案。如果你想让它更像模式匹配，你可以将其打包到 PatternSynonym 中：

tailLast :: [a] -> Maybe ([a], a)
tailLast xs@(_:_) = Just (init xs, last xs)
tailLast _ = Nothing

pattern Split x1 xs xn = x1 : (tailLast -> Just (xs, xn))

然后将你的函数编写为例如

foo :: [a] -> (a, [a], a)
foo (Split head mid last) = (head, mid, last)
foo _ = error "foo: empty list"

Answer 4

这是我学习 Haskell 编程的第一天，我也遇到了同样的问题，但我无法按照之前的解决方案中的建议使用某种外部工件。

我对 Haskell 的感觉是，如果核心语言无法解决你的问题，那么解决方案就是改变你的问题，直到它适用于该语言。

在这种情况下，转换问题意味着将尾部问题转换为头部问题，这似乎是模式匹配中唯一支持的操作。事实证明，您可以使用列表反转轻松地做到这一点，然后使用头元素处理反转列表，就像在原始列表中使用尾元素一样，最后，如果需要，将结果恢复到初始顺序（例如，如果这是一个列表）。

例如，给定一个整数列表（例如[1,2,3,4,5,6]），假设我们要构建这个列表，其中原始列表中从末尾开始的每个第二个元素都被替换为它的双（练习取自家庭作业1 href="http://www.cis.upenn.edu/~cis194/spring13/lectures.html" rel="nofollow noreferrer">这篇关于 Haskell 的精彩介绍) : [2,2,6,4 ,10,6]。

然后我们可以使用以下内容：

revert :: [Integer] -> [Integer]
revert []     = []
revert (x:[]) = [x]
revert (x:xs) = (revert xs) ++ [x]

doubleSecond :: [Integer] -> [Integer]
doubleSecond []       = []
doubleSecond (x:[])   = [x]
doubleSecond (x:y:xs) = (x:2*y : (doubleSecond xs))

doubleBeforeLast :: [Integer] -> [Integer]
doubleBeforeLast l = ( revert (doubleSecond (revert l)) )

main = putStrLn (show (doubleBeforeLast [1,2,3,4,5,6,7,8,9]))

它显然比以前的解决方案长得多，但对我来说感觉更像 Haskell 风格。