删除满足谓词的第一个元素（Haskell）

Question

我想创建一个函数来删除满足第二个参数中给出的谓词的第一个元素。像这样的：

removeFirst "abab" (< 'b')  = "bab"
removeFirst "abab" (== 'b') = "aab"
removeFirst "abab" (> 'b')  = "abab"
removeFirst [1,2,3,4] even  = [1,3,4]

我想通过递归来做到这一点，并想出了这个：

removeFirst :: [a] -> (a -> Bool) -> [a]
removeFirst [] _ = []
rremoveFirst (x:xs) p = if p x then x : removeFirst xs p else removeFirst xs p

（灵感来自this问题） 但我收到一个类型错误，如下所示：

Couldn't match type ‘a’ with ‘Bool’
  Expected: [Bool]
    Actual: [a]
  ‘a’ is a rigid type variable bound by
    the type signature for:
      removeFirst :: forall a. [a] -> (a -> Bool) -> [a]

或者这个：

ghci> removeFirst [1,2,3,4] even

<interactive>:25:1: error:
    * Variable not in scope: removeFirst :: [a0] -> (a1 -> Bool) -> t
    * Perhaps you meant `rem' (imported from Prelude)

我知道这是一个相对简单的编程，只是我对 Haskell 还不够熟悉。我怎样才能做到这种“Haskell 风格”（一行）？

Answer 1

在“按风格”做之前，为什么不先简单地做它，让它工作。这就是我们学习的方式。

"Variable not in scope: removeFirst ..." 仅表示您尚未定义名为removeFirst 的函数。

看来您首先尝试定义它（并且您显示的错误不与您显示的代码一致），然后出现错误，因此没有定义，然后您尝试调用它并得到错误说它尚未定义，自然。

因此，将您的程序保存在源文件中，然后在 GHCi 中加载该文件。然后，如果您遇到任何错误，请将文件中的完整代码复制粘贴到您的问题中（不要不手动重新输入）。另外，准确地，请具体说明您收到错误消息时的操作。并确保通过复制粘贴完整地包含错误消息。

那么你的代码的逻辑就可以解决了。

---

由于其他人已经发布了工作代码，因此我将其编码为一种单行代码：

remFirst :: [a] -> (a -> Bool) -> [a]
remFirst xs p = foldr g z xs xs
  where
  g x r ~(_:tl)      -- "r" for recursive result
     | p x           -- we've found it, then
       = tl          -- just return the tail
     | otherwise
       = x : r tl    -- keep x and continue
  z _  = []          -- none were found

缩短，变成

remFirst xs p = 
  foldr (\x r ~(_:tl) -> if p x then tl else x : r tl)
        (const []) xs xs

Answer 2

不是一行，但它有效。

 removeFirst :: [a] -> (a -> Bool) -> [a]
 removeFirst (x:xs) pred
   | pred x    = xs
   | otherwise = x : removeFirst xs pred

对于单行，我想您可能想使用 foldl 从左侧遍历列表。

编辑

这个解决方案使用守卫，它首先检查传入的列表的第一个元素是否满足谓词，如果不满足，则将其添加到列表的前面并递归检查传入列表的尾部。

Answer 3

使用手动递归不会导致单线解决方案，所以让我们尝试使用库中的一些预构建递归方案。

函数scanl :: (b -> a -> b) -> b -> [a] -> [b] 看起来很方便。它产生一连串状态，每个输入项一个状态。

在ghci解释器下测试：

$ ghci
 λ> 
 λ> p = (=='b')
 λ> 
 λ> xs = "ababcdab"
 λ> ss = tail $ scanl (\(s,n) x -> if (p x) then (x,n+1) else (x,n)) (undefined,0)  xs
 λ> 
 λ> ss
 [('a',0),('b',1),('a',1),('b',2),('c',2),('d',2),('a',2),('b',3)]
 λ> 

此时，通过一些简单的数据按摩，很容易发现并摆脱一个不需要的元素：

 λ> 
 λ> filter (\(x,n) -> (n /= 1) || (not $ p x))  ss 
 [('a',0),('a',1),('b',2),('c',2),('d',2),('a',2),('b',3)]
 λ> 
 λ> map fst $ filter (\(x,n) -> (n /= 1) || (not $ p x))  ss 
 "aabcdab"
 λ> 

现在让我们编写removeFirst 函数。我冒昧地将谓词作为最左边的参数；这就是所有库函数的作用。

removeFirst :: (a -> Bool) -> [a] -> [a]
removeFirst p =
    let
        stepFn = \(s,n) x -> if (p x) then (x,n+1) else (x,n)
        p2     = \(x,n) -> (n /= 1) || (not $ p x)
    in
        map fst . filter p2 . tail . scanl stepFn (undefined,0)

如果需要，可以将此版本更改为单行解决方案，只需将stepFn 和p2 的值扩展到最后一行。留给读者作为练习。它会排长队，因此是否能提高可读性还有待商榷。

附录：

另一种方法是尝试查找库函数，类似于splitAt :: Int -> [a] -> ([a], [a])，但采用谓词而不是列表位置。

所以我们将(a -> Bool) -> [a] -> ([a],[a]) 类型签名提交到Hoogle 专用搜索引擎。

这很容易找到break 库函数。这正是我们所需要的。

 λ> 
 λ> break (=='b') "zqababcdefab"
 ("zqa","babcdefab")
 λ> 

所以我们可以这样写我们的removeFirst函数：

removeFirst :: (a -> Bool) -> [a] -> [a]
removeFirst p xs = let  (ys,zs) = break p xs  in  ys ++ (tail zs)

source code for break 只是使用手动递归。