Haskell：将函数的“列表”结果作为“列表列表”返回，而不使用空列表“[]：foo”

Question

返回列表列表 ([[a]]) 但不使用空列表 ([]:[a]) 的语法是什么（如果可能的话）？ （类似于下面第二个注释的后卫（2），这是不正确的）

这是一个正常工作的函数：

-- Split string on every (shouldSplit == true)
splitWith :: (Char -> Bool) -> [Char] -> [[Char]]
splitWith shouldSplit list = filter (not.null) -- would like to get rid of filter
  (imp' shouldSplit list)
  where 
    imp' _ [] = [[]]
    imp' shouldSplit (x:xs)
      | shouldSplit x  = []:imp' shouldSplit xs  -- (1) this line is adding empty lists
--      | shouldSplit x  = [imp' shouldSplit xs]   -- (2) if this would be correct, no filter needed
      | otherwise  = let (z:zs) = imp' shouldSplit xs in (x:z):zs

这是正确的结果

Prelude> splitWith (== 'a') "miraaaakojajeja234"
["mir","koj","jej","234"]

但是，它必须使用“过滤器”来清理其结果，所以我想摆脱“过滤器”功能。 这是不使用过滤器的结果：

["mir","","","","koj","jej","234"]

如果使用“| shouldSplit x = imp' shouldSplit xs”代替第一个守卫，结果不正确：

["mirkojjej234"]

第一个守卫 (1) 添加空列表，因此（我假设）编译器可以将结果视为列表列表 ([[a]])。

（我对函数的另一种/不同解决方案不感兴趣，只是语法说明。）

.
.
.

回答：

来自 Dave4420 的回答让我找到了答案，但这是一个评论，而不是一个答案，所以我不能接受它作为答案。问题的解决方案是我问错了问题。不是语法问题，而是我的算法问题。

解决空列表问题的另一个/不同解决方案有几个答案，但它们不是我问题的答案。但是，他们扩展了我对如何使用基本 Haskell 语法完成事情的方法的看法，为此我感谢他们。

编辑：

splitWith :: (Char -> Bool) -> String -> [String]
splitWith p = go False
  where 
    go _ [] = [[]]
    go lastEmpty (x:xs)
      | p x        = if lastEmpty then go True xs else []:go True xs
      | otherwise  = let (z:zs) = go False xs in (x:z):zs

Answer 1

这个利用模式匹配来完成单次遍历不产生空交错列表的任务：

splitWith :: Eq a => (a -> Bool) -> [a] -> [[a]]
splitWith f list = case splitWith' f list of
  []:result -> result
  result -> result
  where
    splitWith' _ [] = []
    splitWith' f (a:[]) = if f a then [] else [[a]]
    splitWith' f (a:b:tail) =
      let next = splitWith' f (b : tail)
      in if f a
        then if a == b
          then next
          else [] : next
        else case next of
          [] -> [[a]]
          nextHead:nextTail -> (a : nextHead) : nextTail

运行它：

main = do
  print $ splitWith (== 'a') "miraaaakojajeja234"
  print $ splitWith (== 'a') "mirrraaaakkkojjjajeja234"
  print $ splitWith (== 'a') "aaabbbaaa"

生产：

["mir","koj","jej","234"]
["mirrr","kkkojjj","jej","234"]
["bbb"]

Answer 2

问题很自然地表达为您要拆分的列表的折叠。您需要跟踪两个状态 - 结果列表和正在构建以附加到结果列表的当前单词。

我可能会写一个像这样的幼稚版本：

splitWith p xs = word:result
    where
        (result, word)        = foldr func ([], []) xs
        func x (result, word) = if p x
            then (word:result,[])
            else (result, x:word)

请注意，这也会留在空列表中，因为它会在检测到满足谓词 p 的新元素时将当前单词附加到结果中。

要解决这个问题，只需将列表 cons 运算符 (:) 替换为新运算符

(~:) :: [a] -> [[a]] -> [[a]]

如果原始列表非空，则仅将一个列表转换为另一个列表。算法的其余部分保持不变。

splitWith p xs = word ~: result
    where
        (result, word)        = foldr func ([], []) xs
        func x (result, word) = if p x
            then (word ~: result, [])
            else (result, x:word)
        x ~: xs = if null x then xs else x:xs

你想要什么。

Answer 3

我想我和 Chris 有类似的想法，即使没有那么优雅：

splitWith shouldSplit list = imp' list [] []
  where 
    imp' [] accum result = result ++ if null accum then [] else [accum]
    imp' (x:xs) accum result
      | shouldSplit x  = 
          imp' xs [] (result ++ if null accum 
                                   then [] 
                                   else [accum])
      | otherwise  = imp' xs (accum ++ [x]) result

Answer 4

这基本上只是dropWhile和break的交替应用，不是吗：

splitWith p xs = g xs
   where
     g xs = let (a,b) = break p (dropWhile p xs)
            in if null a then [] else a : g b

您说您对除您的解决方案之外的其他解决方案不感兴趣，但其他读者可能对此感兴趣。它确实很短而且看起来很清楚。随着您的学习，使用基本的Prelude 函数成为第二天性。 :)

至于您的代码，以非必要的方式进行了一些修改（使用简短的暗示性函数名称，例如 p 用于 "predicate" 和 g 用于主要工作函数），它是

splitWith :: (Char -> Bool) -> [Char] -> [[Char]]
splitWith p list = filter (not.null) (g list)
  where 
    g  [] = [[]]
    g (x:xs)
      | p x  = [] : g xs  
      | otherwise  = let (z:zs) = g xs 
                     in (x:z):zs

另外，没有必要将谓词作为参数传递给 worker（正如 cmets 中提到的那样）。现在可以说它更具可读性了。

接下来，稍加改动就变成了

splitWith :: (Char -> Bool) -> [Char] -> [[Char]]
splitWith p list = case g list of ([]:r)-> r; x->x
  where 
    g  [] = [[]]
    g (x:xs)
      | p x  = case z of []-> r;    -- start a new word IF not already
                         _ -> []:r  
      | otherwise  = (x:z):zs
           where                    -- now z,zs are accessible
             r@(z:zs) = g xs        -- in both cases

按您的意愿工作。顶级case 在这里最多删除一个空词，在内部函数工作期间的某个时间点用作分隔符。您的filter (not.null) 在这里基本上融合到工作函数g 中，有条件打开¹一个新词（即添加¹一个空列表）。

将let 替换为where 允许变量（z 等）在g 定义的第二个子句的两个分支中都可以访问。

最后，你的算法已经够接近了，代码还是可以修好的。

---

¹ 思考“从右到左”时。实际上，列表是从左到右构建的，以受保护的递归 ⁄ tail recursion modulo cons 方式。