零・一版分詞實作

book/零．一版/分詞.md

@@ -63,7 +63,7 @@
 
 但無妨，早已有成熟的演算法能應對這類複雜狀況，在零・一版的簡單狀況，倒也不必構思出通用算法才能分詞，只要仔細分析所有狀況就可以了。
 
-為了方便後續表達，先令 x 代表除了零字詞以及[０-９]的所有字元集合。
+為了方便後續表達，先令 x 代表除了單字詞、[０-９]之外，所有的字元集合。
 
 當目前讀取到的字串是...
 
@@ -78,17 +78,15 @@
 - x
     - 必是變數
 
-上述分析以狀態機可表達為下圖
+下圖把上述分析畫成了狀態機，但該圖並沒有畫出所有單字詞，僅以加減為例，其餘單字詞請道友自行想像。
 
 ![零・一版分詞狀態機](../image/零・一版分詞狀態機.png)
 
-其中每個狀態向外的虛線表示，若下個字元匹配不到向外的實線，就走回原點，並以當下狀態分詞。
-
-該圖並沒有畫出所有單字詞，僅以加減為例，其餘單字詞請道友自行想像。
+分詞器會不斷接收到字元，分詞器根據接收的字元維護自身狀態。初始狀態是「起點」，每接收到一個字元，就嘗試匹配實線，若無法匹配，就精油虛線回到原點，並且根據當下狀態分詞。
 
 畫出狀態機之後，以法咒（程式語言）依樣畫葫蘆實作，就是件很容易的事了。
 
-貧道採用 Rust 法咒來撰寫零版編譯器。
+貧道採用 Rust 法咒來撰寫零版編譯器，以下展示實作。
 
 ### 類型定義
 
@@ -117,55 +115,120 @@ pub enum Ｏ詞 {
     數字(i64),
     變數(String),
 }
+```
 
-// TODO: 要實作的分詞術
-pub fn 分詞(源碼: String) -> Vec<Ｏ詞> {
-    unimplemented!();
+接下來，就是把上圖的狀態機刻出來了，觀察狀態轉移的出邊，字符能分為四類，為此貧道寫了以下輔助函數備用：
+
+```rust
+enum Ｏ字類 {
+    特殊符號,
+    數字,
+    元,
+    其他, // 也就是 x
+}
+
+fn 字類(字: &char) -> Ｏ字類 {
+    match 字 {
+        '＋' | '－' | '＊' | '／' | '＝' | '（' | '）' | '・' | '\n' => {
+            Ｏ字類::特殊符號
+        }
+        '元' => Ｏ字類::元,
+        '１' | '２' | '３' | '４' | '５' | '６' | '７' | '８' | '９' | '０' => {
+            Ｏ字類::數字
+        }
+        _ => Ｏ字類::其他,
+    }
 }
 ```
 
-### 處理單字詞
+模擬狀態機最直觀的寫法，定義狀態轉移表，根據接收到的字元，以及建好的表進行狀態轉移。
 
-見招拆招，很容易。
+貧道在此用了稍微不同的寫法，將每個狀態都以一個函式來表達（除了單字詞的情況太簡單，跟起點態的函數寫在一起），函式根據當前字元呼叫另個狀態函式。
+
+這種寫法不用額外宣告一個變數當狀態，當下呼叫到哪個函式，狀態機的狀態就是該函式對應的那個狀態，也可以說狀態其實藏在函式調用棧裡。
 
 ```rust
-pub fn 分詞(源碼: String) -> Vec<Ｏ詞> {
-    let mut 詞列: Vec<Ｏ詞> = Vec::new();
-    for 字 in 源碼.chars() {
+pub struct Ｏ分詞器 {
+    字流: VecDeque<char>,
+}
+
+impl Ｏ分詞器 {
+    pub fn new(源碼: String) -> Self {
+        Ｏ分詞器 {
+            字流: 源碼.chars().collect(),
+        }
+    }
+
+    fn 起點態(&mut self) -> Option<Ｏ詞> {
+        let 字 = self.字流.pop_front()?;
         match 字 {
-            '＋' => {
-                詞列.push(Ｏ詞::運算子(Ｏ運算子::加));
-            }
-            '－' => {
-                詞列.push(Ｏ詞::運算子(Ｏ運算子::減));
-            }
-            '＊' => {
-                詞列.push(Ｏ詞::運算子(Ｏ運算子::乘));
-            }
-            '／' => {
-                詞列.push(Ｏ詞::運算子(Ｏ運算子::除));
+            '＋' => Some(Ｏ詞::運算子(Ｏ運算子::加)),
+            '－' => Some(Ｏ詞::運算子(Ｏ運算子::減)),
+            '＊' => Some(Ｏ詞::運算子(Ｏ運算子::乘)),
+            '／' => Some(Ｏ詞::運算子(Ｏ運算子::除)),
+            '＝' => Some(Ｏ詞::等),
+            '（' => Some(Ｏ詞::左括號),
+            '）' => Some(Ｏ詞::右括號),
+            '・' => Some(Ｏ詞::音界),
+            '\n' => Some(Ｏ詞::換行),
+            '元' => self.元態(),
+            '１' | '２' | '３' | '４' | '５' | '６' | '７' | '８' | '９' | '０' => {
+                self.數字態(字.to_string())
             }
-            '＝' => {
-                詞列.push(Ｏ詞::等);
+            _ => self.變數態(字.to_string()),
+        }
+    }
+    fn 元態(&mut self) -> Option<Ｏ詞> {
+        let 字 = self.字流.front()?;
+        match 字類(字) {
+            Ｏ字類::元 | Ｏ字類::數字 | Ｏ字類::其他 => {
+                self.變數態("元".to_string())
             }
-            '（' => {
-                詞列.push(Ｏ詞::左括號);
+            _ => Some(Ｏ詞::元),
+        }
+    }
+    fn 數字態(&mut self, mut 前綴: String) -> Option<Ｏ詞> {
+        let 字 = self.字流.front()?;
+        match 字類(字) {
+            Ｏ字類::數字 => {
+                前綴.push(self.字流.pop_front()?);
+                self.數字態(前綴)
             }
-            '）' => {
-                詞列.push(Ｏ詞::右括號);
+            Ｏ字類::其他 => {
+                前綴.push(self.字流.pop_front()?);
+                self.變數態(前綴)
             }
-            '元' => {
-                詞列.push(Ｏ詞::元);
+            _ => {
+                let 數 = crate::全形處理::數字::字串轉整數(&前綴);
+                Some(Ｏ詞::數字(數))
             }
-            '・' => {
-                詞列.push(Ｏ詞::音界);
+        }
+    }
+    fn 變數態(&mut self, mut 前綴: String) -> Option<Ｏ詞> {
+        let 字 = self.字流.front()?;
+        match 字類(字) {
+            Ｏ字類::元 | Ｏ字類::數字 | Ｏ字類::其他 => {
+                前綴.push(self.字流.pop_front()?);
+                self.變數態(前綴)
             }
-            _ => {
-                // TODO: 處理多字詞
+            _ => Some(Ｏ詞::變數(前綴)),
+        }
+    }
+
+    pub fn 分詞(mut self) -> Vec<Ｏ詞> {
+        let mut 詞列: Vec<Ｏ詞> = Vec::new();
+        while self.字流.front().is_some() {
+            match self.起點態() {
+                Some(詞) => {
+                    詞列.push(詞);
+                }
+                None => {
+                    panic!("分詞錯誤");
+                }
             }
         }
+        詞列
     }
-    詞列
 }
 ```