如何使用自定义版本的 List：`data List a = Nil |缺点a（列表a）`？

Question

此问题基于 Graham Hutton 第二版“Haskell 编程”一书“声明类型和类”一章中的示例.

数据声明为： data List a = Nil | Cons a (List a)

使用此声明的示例函数是：

len :: List a -> Int
len Nil = 0
len (Cons _ xs) = 1 + len xs

但是无论我怎么尝试，我似乎都无法使用len的功能：

• len Cons 1 Cons 2 Cons 3
• len 1
• len Cons
• len (1)
• len [1,2]
• len Cons [1]
• len (1,2)
• len Cons (1,2)
• len Cons 1 2
• len (Cons (1,2))
• len (Cons 1 2)

我错过了len 和Cons 的任何排列吗？还是这个例子根本行不通？

Answer 1

您传递给len 的参数不是Lists。列表的末尾有Nil，因此列表的形式为Nil、Cons … Nil、Cons … (Cons … Nil)、Cons … (Cons … (Cons … Nil)) 等。所以最终对于每个列表，列表的末尾都标有@987654330 @。 Nil 等同于 Haskell 的 [a] 类型的 []。

此外，例如，您不能传递len Cons 1 Nil，此后它将被解释为((len Cons) 1) Nil。参数应该是一个列表。通过使用括号，您可以将其写为len (Cons 1 Nil)。

对于给定的示例数据，您可以将其重写为：

• len Cons 1 Cons 2 Cons 3 → len (Cons 1 (Cons 2 (Cons 3 Nil)))
• len 1 → len (Cons 1 Nil)
• len Cons → len Nil
• len (1) → len (Cons 1 Nil)
• len [1,2] → len (Cons 1 (Cons 2 Nil))
• len Cons [1] → len (Cons 1 Nil)
• len (1,2) → len (Cons 1 (Cons 2 Nil))
• len Cons (1,2) → len (Cons 1 (Cons 2 Nil))
• len Cons 1 2 → len (Cons 1 (Cons 2 Nil))
• len (Cons (1,2)) → len (Cons 1 (Cons 2 Nil))
• len (Cons 1 2) → len (Cons 1 (Cons 2 Nil))

您也可以使用OverloadedLists [haskell-doc] 扩展名来使用列表语法。在这种情况下，您需要实现IsList 类型类：

{-# LANGUAGE TypeFamilies #-}

import GHC.Exts(IsList(..))

data List a = Nil | Cons a (List a)

instance IsList (List a) where
    type Item (List a) = a
    toList Nil = []
    toList (Cons x xs) = x : toList xs
    fromList [] = Nil
    fromList (x:xs) = Cons x (fromList xs)

如果您随后启用 OverloadedLists 扩展，您可以将这些写为列表文字：

{-# LANGUAGE OverloadedLists #-}

-- …

main = print (len [1,2])

Answer 2

您完全按照定义使用函数：

len  Nil         = 0
len (Cons _x xs) = 1 + len xs

那么，

list1 = Nil           -- matches the first pattern
list2 = Cons 2 list1  -- matches the second pattern
list3 = Cons 3 list2  -- matches the second pattern
list4 = Cons 4 list3  -- matches the second pattern

等等等等。

手工写出这样的示例数据，我们需要使用括号正确分组子术语以重新创建有效术语，例如

list5 = Cons 5 list4
      = Cons 5 (Cons 4 list3)
      = Cons 5 (Cons 4 (Cons 3 list2))
      = ...
      = Cons 5 (Cons 4 (Cons 3 (Cons 2 Nil)))

这一切甚至都没有查看数据类型定义。

当然可以使用任何东西来代替1、2 等，只要它们都是相同的类型，例如以下也是一个有效的术语：

list54 = Cons list5 (Cons list4 Nil)

为什么？由于数据类型的定义，

data List a = Nil           --  `Nil` constructs (is) a valid `List a` type term,
            |               -- OR,
              Cons          --  `Cons x xs` constructs (is) a valid `List a` type term,  IF 
                   a        --       `x` is a valid term of type `a`                  ,  AND
                  (List a)  --       `xs` is a valid term of type `List a`

Nil 构造（是）一个有效的List a 类型术语，而Cons x xs 构造（是）一个有效的List a 类型术语，如果 x 是一个有效的术语键入a 和 xs 是List a 类型的有效术语，其中a 是一回事。

例如根据List a 数据类型定义，Cons 1 (Cons list2 Nil) 不是有效术语，尽管函数 len 似乎也可以处理它。