我想更好地理解我正在學習的課程中正在查看的一些代碼。我使用 Ghci 來推斷(:)to be的型別(:) :: a -> [a] -> [a]。我想確切地知道該功能是如何實作的，但我找不到任何東西。
uj5u.com熱心網友回復：
第一級答案是它只是串列的資料建構式。如果語法有效，您可以想象：
data [a] = [] | a : [a]
比較例如 的定義Complex：
data Complex a = a : a
或者Two：
data Two a = Two a a
如果需要，您可以定義自己的類似串列；說
data List a = Nil | Cons a (List a)
然后(:)和Cons將具有基本相同的實作。
但是接下來明顯的問題是：資料建構式是如何實作的？回答這個問題使我們脫離了 Haskell 語言的領域，進入了特定的 Haskell 實作領域。一個對 GHC 的實作很有幫助的心智模型，盡管有點錯誤，是這樣的：當你將一個資料建構式應用到足夠多的引數時，你會得到一個新的指標，指向一個有數字的記憶體塊（告訴哪個它是許多建構式），然后是更多的指標（建構式的每個欄位一個）。所以，對于串列，你會有這樣的東西：
term | memory
------- -----------------------------------------------------
| ------------
[] | | 00000000 |
| ------------
| tag
|
| ----------------------------------------------------
a : as | | 00000001 | 00101110100111000 | 00001010111011000 |
| ----------------------------------------------------
| tag pointer to a pointer to as
uj5u.com熱心網友回復：
:是串列型別的資料建構式之一，因此它不是一個以普通 Haskell 代碼作為實作的函式，如 . 串列的特殊語法有點妨礙解釋，所以我將從不同的型別開始，然后回到真正的串列。讓我們看看這個：
data List a
= Nil
| Cons a (List a)
這定義了兩個建構式：Nil和Cons。Nil沒有任何引數，所以它只是一個型別的值List a（對于 any a）。Cons有兩個引數；需要 aa和 aList a才能產生 type 的值List a。
這意味著我們可以Cons完全像普通函式一樣使用。我們向它傳遞引數并獲得回傳值。這讓我們想知道該功能的實作是什么。普通函式由代碼定義；當你應用一個函式時，你運行它的代碼1，而無論該代碼產生什么都是函式的回傳值。應用資料建構式時運行什么代碼？
答案實際上是否定的。資料建構式是特殊的，盡管我們可以像應用函式一樣應用它們。資料建構式是我們將新型別的值引入程式的方式，因此它們不能使用代碼定義（這將導致現有事物的某種組合，而不是新型別的值）。
資料構造器也是模式匹配的基本構建塊。您可以檢查一個值以查看它是否是Cons應用于其他兩個值的建構式，如果是，則可以訪問它們。當你有一個由代碼而不是資料建構式產生的值時，沒有辦法判斷它是否是特定函式的產物（更不可能的是“取消應用”代碼并找出引數是什么是）。但是資料建構式可以通過這種方式不應用，而這正是模式匹配起作用的原因。
Haskell 提供資料建構式的這兩個特性（創建新型別的值，并能夠取消應用它們以獲取引數值）的方式不是通過運行代碼來實作它們。相反，當我們說 時Cons True Nil，引數只是按原樣存盤。Cons True Nil不運行任何代碼來產生某些東西；aCons只是一個帶有兩個插槽的值，而 aCons True Nil只是一個Cons帶有 aTrue和 a填充的插槽的值Nil。這保證了這確實是一種新的值，任何現有型別都無法生成（因為它們都有自己的資料建構式，而不是 new Cons）。并且它可以很容易地判斷引數Cons是什么：Haskell 可以只查看兩個插槽。2
我承諾我會把它帶回真正的 Haskell 串列，所以讓我們這樣做吧。該型別[a]及其建構式是 Haskell 內置的，但它們的行為與我上面定義的自制串列型別完全相同！由于使用了不尋常的語法，有時很難看出它們有多“正常”，但看看這些：
-- definition 1
data List a
= Nil
| Cons a (List a)
-- definition 2
data List a
= Nil
| a `Cons` List a
-- definition 3
data [] a
= []
| (:) a ([] a)
-- definition 4
data [a]
= []
| a : [a]
所有這些都定義了具有相同結構的型別（與內置串列型別的結構相同）。
定義 1 和 2 實際上定義了完全相同的型別；您可以在帶有兩個引數的名稱周圍使用反引號 ( `) 將其應用在其引數之間而不是之前的中綴。這適用于建構式名稱，您可以在建構式的定義中很好地做到這一點。
Definitions 3 and 4 are the similar pattern but using the actual "names" used by the built in list type. You cannot actually enter either of these in your Haskell code only because it's not valid to use the special list syntax in your own definitions, but the built in list type behaves as-if it was defined by one of these. In definition 3 I've applied [] type constructor3 using ordinary prefix application ([] a just like I used List a in my other two definitions), and similarly applied the : constructor using prefix notation (surrounding the operator : with parentheses, as we can do with any operator like ( ) 1 2). While definition 4 mirrors the pattern of definition 2, using an infix constructor :, and also fully uses the unique [a] syntax for the list type.
So you see, : actually has no implementation (at the Haskell level). True : [] just is the : constructor applied to the arguments True and []; it does not do any work to evaluate to anything else. It is also handy as a "prepend operator", but the way the list type is defined makes : special. For example, the operator (for appending) needs to be defined in terms of prepending because we defined the list structure in terms of prepending (i.e. :). Prepending does not need to be defined in terms of anything else, because it is what we define lists in terms of. That's why you can't find any definition for : (well, that and the fact that the standard list type is built in to the compiler, so you can't even find a data declaration for it).
1 With the parameter variables bound to the argument values you supplied.
2These abilities to "just store values" and "look in the slots" is something that is just a built-in fundamental concept of Haskell. They are the building blocks in terms of which the language Haskell is defined, rather than being something that is coded in ordinary Haskell. But they do of course have an implementation in lower level code that the compiler supplies; Daniel Wagner's answer talks a little bit about that, if you are interested.
3 This is one of the things that makes it hard to see how "normal" the list type is, having special rules for how you can write lists but none at all for how they behave. On the value level, the [] symbol is a data constructor with zero arguments, and surrounding something with square brackets like [True] is special syntactic sugar constructing a list (involving both constructors, in our case: True : []).
While on the type level, the same symbol [] is a type constructor with one argument, and wrapping something in square brackets like [Bool] is special syntactic sugar for applying the [] type constructor to it (in our case: [] Bool).
If I were redefining the Haskell language from scratch with the benefit of hindsight, I would name the list type constructor List, keeping the square bracket syntax solely for defining list values at the term level. I might even go so far as to use a "normal" name for the empty list constructor rather than [], leaving square brackets purely involved in the special syntactic sugar and not at all involved in the actual definition of the underlying type, which would then be perfectly ordinary in spelling as well as behaviour. The syntax for list types is cute, and very slightly shorter, but I think it ultimately hinders understanding rather than promoting it. (For beginners; once you're sufficiently used to it either way works fine)
Although [] is quite satisfying as a symbol for the empty list constructor, since the square bracket syntactic sugar would still define [] as a way of writing an empty list regardless, so maybe I'd be tempted to keep that.
轉載請註明出處，本文鏈接：https://www.uj5u.com/shujuku/446075.html
上一篇：無法理解Haskell中`foldr`和`map`的行為
下一篇：Haskell-無法匹配型別