使用代数数据类型组合列表

Question

我正在尝试了解创建的代数数据类型的语法。我创建的类型是[Int] 或Empty，类似于Maybe 与Just 和Nothing，除了Just 必须是Int 的列表。当它接受两个输入并给出相同类型的输出时，我无法理解如何操作创建的类型。

data Example = Arg [Int]
         | Empty
    deriving Show

我使用模式匹配并理解必须解决每种情况；但是，我的问题来自最终模式的语法，Empty 都不是。我正在尝试编写两个函数：一个结合来自Example 构造函数的[Int] 列表，并且我想创建一个只显示一组[Int] 共享的函数，而不是组合。

第一个问题是合并两个集合。我可以在普通函数中执行此操作，但在某个地方，使用 Example 数据类型，语法已关闭，我不熟悉它。第二个最大的问题是相同的：我了解递归，但我不了解创建的数据类型中递归的语法。我也在考虑在第二个函数中使用where 语句，但如果我不能正确获得基本递归的语法，那么我怀疑它会成功。

combine :: Example -> Example -> Example
combine Empty Empty = Empty
combine (Arg xs) Empty = (Arg xs)
combine Empty (Arg ys) = (Arg ys)
combine (Arg xs) (Arg ys) = Arg xs ++ ys

same :: Example -> Example -> Example
same _ Empty = Empty
same Empty _ = Empty
same (Arg x : xs) (Arg y : ys)
  | x == y    = x
  | otherwise = same (Arg xs) (Arg ys)

combine 的输出应该是一个 [Int] 列表，其中包含两个列表中的所有 Ints；如果一个列表为空，它应该返回整组非空列表。

same 的输出应该包含一个[Int] 列表，该列表仅包含两个组共享的数字，没有重复；如果一组为空，则输出为空。

Answer 1

使用lifting的概念，我得出了这个解决方案：

import Data.List (nub)

data Example = Arg [Int]
         | Empty
    deriving Show

combine :: Example -> Example -> Example
combine Empty Empty = Empty
combine x Empty = x
combine Empty x = x
combine (Arg xs) (Arg ys) = Arg $ nub $ xs ++ ys

same :: Example -> Example -> Example
same arg1 arg2 = lift nub $ same' arg1 arg2
    where
        same' _ Empty = Empty
        same' Empty _ = Empty
        same' (Arg []) y = Arg []
        same' (Arg (x : xs)) (Arg (ys))
            | x `elem` ys = lift (x : ) $ same' (Arg xs) (Arg ys)
            | otherwise  = same' (Arg xs) (Arg ys)

lift :: ([Int] -> [Int]) -> Example -> Example
lift _ Empty = Empty
lift f (Arg x) = Arg (f x)

lift 所做的是将函数应用于Arg 的“内容”。如果你有表达式same (Arg [1, 2, 4, 3]) (Arg [3,1,4])，递归将把它变成：

lift nub $ lift (1 : ) $ lift (4 : ) $ lift (3 : ) $ Arg []

评价如下：

lift nub $ lift (1 : ) $ lift (4 : ) $ Arg (3:[])
lift nub $ lift (1 : ) $ Arg (4:3:[])
lift nub $ Arg (1:4:3:[])
Arg (nub $ 1:4:3:[])

最后：

Arg [1,4,3]

Answer 2

combine :: Example -> Example -> Example
combine x Empty = x
combine Empty x = x
combine (Arg xs) (Arg ys) = Arg $ union xs ys

union xs ys = nub $ xs ++ ys
nub [] = []
nub (x:xs) = if x `elem` xs then nub xs else x : nub xs

same :: Example -> Example -> Example
same _ Empty = Empty
same Empty _ = Empty
same (Arg xs) (Arg ys) = Arg $ intersect xs ys

intersect _ [] = [] -- unnecessary but practical!
intersect [] _ = []
intersect (x:xs) ys = if x `elem` ys then x : intersect xs ys else intersect xs ys

作为 Robin cmets，您有几个不同的问题。首先，您需要匹配所有案例，其次您需要将结果包装回您的数据类型，第三您需要删除联合中的重复项，第四您的“设置交集”操作仅适用于一些非常强的假设输入列表的结构。 union、intersect（也可在 Data.List 中使用）足以用于演示目的而无需调用例如。 Data.IntSet.toList . Data.IntSet.fromList 虽然这样会更快。您的版本（如果稍作修正）将输出出现在两个列表中相同位置的元素。

关于函子的常见教程通常以Maybe 开头，这可能有助于您理解这一点，因为Example 与Maybe [Int] 同构。

您可能希望使用Arg (x : xs) 解构函数的示例是一个函数，该函数从两个列表中的每个索引处获取较小的元素。您可以尝试递归地自己编写，即。不使用zip？

编辑：重大更改和更正