Haskell中列表中的模式匹配元素

Question

假设我有以下类型，在其他地方定义了KType：

data PExpr = 
    PVal KType |
    PCall String [PExpr]

我有一个功能：

tryReplace:: PExpr -> Maybe PExpr 

出于我们的目的，请执行以下操作：

1. 如果给定的PEXPR是PVAL，则无需返回
2. ，如果给定的PEXPR是PCALL，并且是空的，并且是空的
3. 如果给定的PEXPR是PCALL，则一无所获，并且完全由PVAL
4. 返回（仅PEXPR）组成，如果给定的PEXPR是PCALL，并且在列表中具有PCALL，则列表中发现的第一个PCALL被全球定义的KType替换x。

到目前为止，这就是我完成1和2的方式：

tryReplace (PVal _) = Nothing
tryReplace (PCall _ []) = Nothing

我对实现＃4时的＃3保留版本不太确定：

tryReplace (PCall _ [PVal _]) = Nothing
tryReplace (PCall str (PVal x:xs)) = tryReplace (PCall str xs)

我本质上希望＃4这样的模式匹配：

tryReplace (PCall str (PVal a:PVal b:...:PCall _:rest)) = 
    Just (PCall str (PVal a:PVal b:...:PVal newValue:rest))

“ ...”应该在找到PCALL之前代表所有PVAL。

我敢肯定，有一个功能可以做到与已经定义的非常相似的功能，但是无论我尝试实现自己的版本。

除非有一个单个模式函数匹配案例可以照顾＃3，否则我无法想到＃4工作的一种方法，因为我认为我会在穿越给定列表时被迫构建列表。但是，如果找到PCALL，则可能不会返回所构建的列表，这意味着一无所有。我应该怎么做？我应该定义另一个功能以帮助实施＃4吗？

Answer 1

您可以使用一个附加功能，该功能将找出列表是否满足＃3或＃4，并相应地返回替代列表，

hasPCall :: [PExpr] -> (Bool, [PExpr])
hasPCall [] = (False, [])
hasPCall (PCall _ _ : rst) = (True, (PVal newValue:rst))
hasPCall (PVal a : rst) = (fst val, (PVal a:snd val))
    where
        val = hasPCall rst

tryReplace:: PExpr -> Maybe PExpr
tryReplace (PVal _) = Nothing
tryReplace (PCall _ []) = Nothing
tryReplace (PCall s n) = case val of
    (True, a) -> Just (PCall s (snd newlist))
    (False, _) -> Nothing
  where
    newlist = hasPCall n

而不是（bool，[pexpr]），，只是[PEXPR]可以为haspcall实现，但这比这更凌乱。

Answer 2

让我们简化。假设您有一个项目列表，可以是a，b，c：

data Item = A | B | C
  deriving (Show)

xs1 = []
xs2 = [A, B, B, A, A]
xs3 = [A, A, A, A, A]
xs4 = [B, B, B, A, B]
xs5 = [A, A, A, A, B]

我们可以添加布尔值以记住我们只有到目前为止看到a s：

import Control.Arrow

process :: (Bool, [Item]) -> (Bool, [Item])
process (_, []) = (True, [])
process (_, A:xs) = second (A :) (process (True, xs))
process (_, B:xs) = (False, C : xs)

在这里我们使用 second @（ - ＆gt;）::（b - ＆gt; c） - ＆gt; （d，b） - ＆gt; （d，c） 在结果元组的第二部分中添加a：

ghci> :set -XTypeApplicationsghci>
:t second @(->)
second @(->) :: (b -> c) -> (d, b) -> (d, c)
ghci> second (A:) (True, [B, C])
(True,[A,B,C])

它将给我们：

ghci> process (True, xs1)
(True,[])
ghci> process (True, xs2) 
(False,[A,C,B,A,A])
ghci> process (True, xs3)
(True,[A,A,A,A,A])
ghci> process (True, xs4)
(False,[C,B,B,A,B])
ghci> process (True, xs5)
(False,[A,A,A,A,C])

借助 state monad 我们甚至可以隐藏输入bool get：

process' :: State [Item] Bool
process' = state go
  where
    go [] = (True, [])
    go (A:xs) = second (A:) (go xs)
    go (B:xs) = (False, C:xs)

给出相同的结果：

ghci> runState process' xs1
(True,[])
ghci> runState process' xs2
(False,[A,C,B,A,A])
ghci> runState process' xs3
(True,[A,A,A,A,A])
ghci> runState process' xs4
(False,[C,B,B,A,B])
ghci> runState process' xs5
(False,[A,A,A,A,C])