3

（在我的实际用例中，我有一个 type 列表[SomeType]，SomeType具有有限数量的构造函数，全部为空；在下面我将使用String而不是[SomeType]并且仅使用 4 Chars，以简化一点。）

我有一个这样的列表"aaassddddfaaaffddsssadddssdffsdf"，其中每个元素都可以是'a', 's', 'd',中的一个'f'，并且我想对每个连续的非as 序列做一些进一步的处理，比如说将它们变成大写并反转序列，从而获得"aaaFDDDDSSaaaSSSDDFFaFDSFFDSSDDD". （我添加了反转要求，以明确处理同时涉及所有连续的非'a'-s。）

要转换每个子String大写，我可以使用这个：

func :: String -> String
func = reverse . map Data.Char.toUpper

但是我如何只在non -sfunc的 sub- s 上运行呢？String'a'

我的第一个想法是这Data.List.groupBy很有用，整体解决方案可能是：

concat $ map (\x -> if head x == 'a' then x else func x)
       $ Data.List.groupBy ((==) `on` (== 'a')) "aaassddddfaaaffddsssadddssdffsdf"

然而，这个解决方案并不能说服我，因为我== 'a'在分组（对我来说这似乎很好而且不可避免）和决定是否应该将一个组变为大写时都使用。

我正在寻找有关如何以最佳方式完成这项小任务的建议。

4

5 回答 5

1

如果我们需要记住'a's 和其余部分的区别，让我们将它们放在 s 的不同分支中Either。事实上，现在我们来定义一个新类型：

{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE ViewPatterns #-}

import Data.Bifoldable
import Data.Char
import Data.List

newtype Bunched a b = Bunched [Either a b] deriving (Functor, Foldable)

instance Bifunctor Bunched where
  bimap f g (Bunched b) = Bunched (fmap (bimap f g) b)

instance Bifoldable Bunched where
  bifoldMap f g (Bunched b) = mconcat (fmap (bifoldMap f g) b)

fmap将让我们处理非分隔符。fold将返回非分隔符的串联，bifold将返回所有内容的串联。当然，我们可以定义与Foldableand无关的单独函数Bifoldable，但为什么要避免已经存在的抽象呢？

要拆分列表，我们可以使用一个unfoldr交替搜索as 和非as 的span函数：

splitty :: Char -> String -> Bunched String String
splitty c str = Bunched $ unfoldr step (True, str)
  where
    step (_, []) = Nothing
    step (True, span (== c) -> (as, ys)) = Just (Left as, (False, ys))
    step (False, span (/= c) -> (xs, ys)) = Just (Right xs, (True, ys))

让它发挥作用：

ghci> bifold . fmap func . splitty 'a' $ "aaassddddfaaaffddsssadddssdffsdf"
"aaaFDDDDSSaaaSSSDDFFaFDSFFDSSDDD"

注意：Bunched实际上与 bifunctors 包中的相同Tannen [] Either，如果你不介意额外的依赖。

于 2020-09-25T16:21:04.197 回答
1

您可以在分组之前按谓词对列表元素进行分类。请注意，我颠倒了谓词的含义，以指示哪些元素要进行转换，而不是保留哪些元素。

{-# LANGUAGE ScopedTypeVariables #-}

import Control.Arrow ((&&&))
import Data.Function (on)
import Data.Monoid (First(..))

mapSegmentsWhere
  :: forall a. (a -> Bool) -> ([a] -> [a]) -> [a] -> [a]
mapSegmentsWhere p f
  = concatMap (applyMatching . sequenceA)  -- [a]
  . groupBy ((==) `on` fst)                -- [[(First Bool, a)]]
  . map (First . Just . p &&& id)          -- [(First Bool, a)]
  where
    applyMatching :: (First Bool, [a]) -> [a]
    applyMatching (First (Just matching), xs)
      = applyIf matching f xs

    applyIf :: forall a. Bool -> (a -> a) -> a -> a
    applyIf condition f
      | condition = f
      | otherwise = id

示例使用：

> mapSegmentsWhere (/= 'a') (reverse . map toUpper) "aaassddddfaaaffddsssadddssdffsdf"
"aaaFDDDDSSaaaSSSDDFFaFDSFFDSSDDD"

在这里，我使用Firstmonoid withsequenceA来合并从[(Bool, a)]to的相邻匹配元素列表(Bool, [a])，但您也可以使用类似map (fst . head &&& map snd). ScopedTypeVariables如果您不想编写类型签名，也可以跳过；为了清楚起见，我只是将它们包括在内。

于 2020-09-25T17:40:59.427 回答
1

这里还有其他答案，但我认为他们对迭代抽象过于兴奋。手动递归，交替取与谓词匹配的东西和不匹配的东西，使这个问题变得非常简单：

onRuns :: Monoid m => (a -> Bool) -> ([a] -> m) -> ([a] -> m) -> [a] -> m
onRuns p = go p (not . p) where
    go _ _ _ _ [] = mempty
    go p p' f f' xs = case span p xs of
        (ts, rest) -> f ts `mappend` go p' p f' f rest

在 ghci 中尝试一下：

Data.Char> onRuns ('a'==) id (reverse . map toUpper) "aaassddddfaaaffddsssadddssdffsdf"
"aaaFDDDDSSaaaSSSDDFFaFDSFFDSSDDD"
于 2020-10-02T21:47:30.223 回答
0

这是一个简单的解决方案 -process下面的函数 - 只需要您定义两个函数isSpecial和func. 给定来自您的 type 的构造函数SomeType，isSpecial确定它是否是构成特殊子列表的构造函数之一。该功能func是您在问题中包含的功能；它定义了特殊子列表应该发生的事情。

下面的代码用于字符列表。只需更改isSpecial并func使其适用于您的构造函数列表。

isSpecial c = c /= 'a'
func = reverse . map toUpper

turn = map (\x -> ([x], isSpecial x)) 

amalgamate []  = []
amalgamate [x] = [x]
amalgamate ((xs, xflag) : (ys, yflag) : rest)
   | xflag /= yflag = (xs, xflag) : amalgamate ((ys, yflag) : rest)
   | otherwise      = amalgamate ((xs++ys, xflag) : rest)

work = map (\(xs, flag) -> if flag then func xs else xs)

process = concat . work . amalgamate . turn

让我们在您的示例中尝试一下：

*Main> process "aaassddddfaaaffddsssadddssdffsdf"
"aaaFDDDDSSaaaSSSDDFFaFDSFFDSSDDD"
*Main>

一次应用一个函数，显示所采取的中间步骤：

*Main> turn "aaassddddfaaaffddsssadddssdffsdf"
[("a",False),("a",False),("a",False),("s",True),("s",True),("d",True),
("d",True),("d",True),("d",True),("f",True),("a",False),("a",False),
("a",False),("f",True),("f",True),("d",True),("d",True),("s",True),
("s",True),("s",True),("a",False),("d",True),("d",True),("d",True),
("s",True),("s",True),("d",True),("f",True),("f",True),("s",True),
("d",True),("f",True)]
*Main> amalgamate it
[("aaa",False),("ssddddf",True),("aaa",False),("ffddsss",True),
("a",False),("dddssdffsdf",True)]
*Main> work it
["aaa","FDDDDSS","aaa","SSSDDFF","a","FDSFFDSSDDD"]
*Main> concat it
"aaaFDDDDSSaaaSSSDDFFaFDSFFDSSDDD"
*Main>
于 2020-09-26T15:52:22.837 回答
0

我们可以按照您的描述一步一步地做，得到一个清晰简单的最小代码，我们以后可以轻松阅读和理解：

foo :: (a -> Bool) -> ([a] -> [a]) -> [a] -> [a]
foo p f xs = [ a
         | g <- groupBy ((==) `on` fst) 
                      [(p x, x) | x <- xs]  -- [ (True, 'a'), ... ]
         , let (t:_, as) = unzip g          -- ( [True, ...], "aaa" )
         , a <- if t then as else (f as) ]  -- final concat

         -- unzip :: [(b, a)] -> ([b], [a])

我们将列表分成相同的p跨度，并在unzip. 尝试一下：

> foo (=='a') reverse "aaabcdeaa"
"aaaedcbaa"

所以不，使用== 'a' 是可以避免的，因此不是特别好，当我们需要的只是布尔值的相等性时，会对您的数据类型引入不必要的约束。

于 2021-02-13T14:08:28.573 回答