简单但强大的 Pratt Parsing【译】

Alex Kladov — Thu, 01 Aug 2024 00:00:00 +0000

                 Parser  "1 + 2 * 3"   完成这项任务的方法有很多，大致可以分为两类：</p>  使用 DSL 指定语言的抽象语法</li> 手写解析器</li> </ul> Pratt 解析是手写解析最常用的技术之一。</p> 语法分析理论的巅峰是发现了上下文无     StructItem</span   | EnumItem</span><   | ...</span></ </span> StructItem ::=</span     'struct' </span> ...</span></spa 我记得我曾经很喜欢这个想法，尤其是     Expr '+'   | Expr '*'   | '('   | 'number'< 虽然这个语法看起来很棒，但实际上它     Factor</span><&#   | Expr '+' Factor ::=</span><&#     Atom</span><   | Factor '*' Atom ::=</span><     'number'<   | '(' 对我来说，表达式的“形状”在这个新 
这就是我喜欢 Pratt 解析的原因——它是 手写解析器的最简单技术是递归下降法         }</span></s }</span></span> </span> fn</span>     }</span></span> </span>     Sum '+'   | Int</span></ 确实，如果我们简单地编写 sum</code>     </span>   }</span></span>  这时我们立即进入了死循序并且发生栈溢出</li> </ol> 该问题的理论上解决方法包括重写语法 仅使用循环不足以解析中缀表达式。因此，Pratt          }</span></s }</span></span> 它不仅能让你的思维进入莫比乌斯环形 power:      3       3 *</code> 绑定力更强，它能更有力地将 
那么结合性又是什么呢？在 A power:  0      3 在这里，我们稍微增加了 +</code>  译注：观察 A</code> 两侧，3 </blockquote> power:  0 现在我们可以折叠第二个加号并得到 
Pratt 解析的作用是通过从左到右处理字 0   8.5    8   8.5 我们将要解析一种将单字符</em>数    }</span></span> </span>  }</span></span> </span> impl<&#                    })</span        }</span></s </span>       }</span></s       }</span></s }</span></span> 为了确保我们得到正确的优先级<&#x  译注：S-表达式也叫做波兰表达式。</p> </blockquote> 
</span>   }</span></span> </span> impl<&#                      }</span>         }</span><&#x     }</span></s }</span></span> 让我们从这里开始：带有原子和两个中 
 }</span></span> </span> fn</span> }</span></span> </span> #[test]</span></ fn</span>  }</span></span> 所以，我们用来处理左递归的方法大体 
       };</span></ </span>              };</span><&# </span>      }</span></s </span>  }</span></span> </span> #[test]</span></ fn</span>  }</span></span>  请注意，我们已经可以解析这个简单的测试了！</li> </ol> 我们想要使用这个绑定力的想法，所以 
 译注：+</code>、-</code>、 </blockquote> 
       };</span></ </span>              };</span><&#  </span>      }</span></s </span>  }</span></span> </span> fn</span>        }</span></s }</span></span> 现在到了巧妙的部分，让我们引入递归 
  1   2   3   4 光标在第一个 +</code> 号处，我 
瞧，我们有了一个功能齐全的最小 Pratt 解析器：</p> 
 }</span></span> </span> fn</span>      };</span></ </span>              };</span><&# </span>            }</span><&#x </span>   </span>      }</span></s </span>  }</span></span> </span> fn</span>        }</span></s }</span></span> </span> #[test]</span></ fn</span>  </span>   </span>   }</span></span>  min_bp</code> 参数是关键的补充。 
这是“停止”的点。</li> 
在这里我们越过运算符本身并进行递归 
最后，在解析正确的右侧之后，我们组 
开始递归时，我们使用的绑定力为零。 </ol> 是的，这 40 行就是</em> Pratt 
现在让我们添加各种奇怪的表达式来展          }</span></s }</span></span> 是的，只有一行！请注意运算符的左侧 </span>        }</span></s }</span></span> </span> fn</span>         }</span></s }</span></span>  在这里，我们返回一个空 ()</c 注意，因为我们想在 .</code> </ol> 将其插入 expr_bp</code>，我们得到             }</span><&#x      };</span></  }</span></span> 现在，我们只有 r_bp</code>              }</span><&#x      };</span></ </span>              };</span><&# </span>            }</span><&#x </span>   </span>      }</span></s </span>  }</span></span> </span> #[test]</span></ fn</span> </span>   </span>   }</span></span> 有趣的是，这种纯粹机械化、类型驱动 
好吧，越来越简单了。如果使用  }</span></span> </span>  }</span></span> 等等，这里有些问题。在我们解析前缀              }</span><&#x      };</span></ </span>              };</span><&# </span>      </span>           }</span </span>            }</span><&#x </span>   </span>      }</span></s </span>  }</span></span> </span> fn</span>       }</span></s }</span></span> </span> fn        };</span><&  }</span></ </span> fn</span>         }</span></s }</span></span> </span> #[test]</span></ fn</span>  </span>   }</span></span> 很好，新旧测试都通过了。</p> 
现在，我们准备添加一种新的表达式： 
         }</span></s         }</span></s  };</span></span 不幸的是，以下测试失败：</p> 
            }</span             }</span><&#x      };</span></ </span>              };</span><&# </span>                }</span>  </span>           }</span><&#x </span>     </span>   </span>           }</span </span>      }</span></s </span>  }</span></span> </span> fn</span>       }</span></s }</span></span> </span> fn</span>       };</span></  }</span></span> </span> fn          };</span><&  }</span></ 现在让我们添加数组索引运算符： 
             }</span><&#x             }</span><&#x      };</span></ </span>              };</span><&# </span>                }</span>  </span>                }</span><&#x </span>                }</span> </span>   </span>           }</span><&#x </span>      }</span></s </span>  }</span></span> </span> fn</span>       }</span></s }</span></span> </span> fn</span>       };</span></  }</span></span> </span> fn</span>         };</span></  }</span></span> </span> #[test]</span></ fn</span> </span>   }</span></span>  注意，我们为 !</code> 和 </ol> 最后，所有运算符的最终 boos，可怕的三元运算符：</p> 
这是……“所有其他地方”类型运算符 让我们回忆一下，a[i]</code> 为了弄清楚这一点，我们只需要将括号部分变形：</p> 这可以解析为</p> 或者</p> 哪一种更有用呢？对于这样的 ?</code> c ? d :</span></ e</span></span> 右结合的解读更有用。在优先级方面， 
这是我们最完整、最完美的简单 Pratt 解析器版本：</p> 
</span>   }</span></span> </span> impl<&#                      }</span>         }</span><&#x     }</span></s }</span></span> </span> #[derive(</span>   }</span></span> </span>  }</span></span> </span> impl<&#                    })</span        }</span></s </span>       }</span></s       }</span></s }</span></span> </span> fn</span> }</span></span> </span> fn</span>             }</span><&#x             }</span><&#x      };</span></ </span>              };</span><&# </span>                }</span>  </span>                 }</span>             };</span          }</span><&#x </span>                }</span>  </span>                  }</span>              };</span          }</span><&#x </span>      }</span></s </span>  }</span></span> </span> fn</span>       }</span></s }</span></span> </span> fn</span>        };</span></  }</span></span> </span> fn</span>           };</span></  }</span></span> </span> #[test]</span></ fn</span>  </span>   </span>   </span>   </span>         );</span></ </span>   </span>   </span>   </span>   </span>   </span>   </span>         );</span></  </span>   }</span></span> </span> fn</span>        }</span></s }</span></span> 代码也可以在https://matklad.github.io/2020/04/13/simple-but-powerful-pratt-parsing.html</a></strong></p> monad 教程。关于 Pratt 解析文章数量如此之多，以至于存在一个调查帖子</a> :)</p> 被夸大了。</li> Pratt 解析算法的描述和实现。</li> rel="noopener nofollow noreferrer external" target="_blank" href="https://github.com/rust-analyzer/rust-analyzer/blob/c388130f5ffbcbe7d3131213a24d12d02f769b87/crates/ra_parser/src/grammar/expressions.rs#L280-L281">实现过</a>一个生产级的 Pratt 解析器，但我不再理解该代码:-)</li> 解，例如，本文没有解释什么是上下文无关语法（context free grammar）。</p> aria-label="Anchor link for: 介绍">介绍</a></h2> 换为树</em>表示的过程：</p> class="giallo-l">                            Add</span></span> / \</span></span> ------->   1  Mul</span></span> / \</span></span> 2   3</span></span></code></pre> aria-label="Anchor link for: BNF">BNF</a></h2> 关语法符号（通常使用 BNF 具体语法）用于将线性结构解码为树：</p> class="giallo-l">Item ::=</span></span> ></span> /span> ;span> ></span> Name '{' FieldList '}'</span></span> n></code></pre> 它与自然语言句法结构的相似性。然而，一旦我们开始描述表达式，我的乐观很快就消失了。自然表达式语法确实让人们了解表达式是什么。</p> class="giallo-l">Expr ::=</span></span> Expr</span></span> Expr</span></span> Expr ')'</span></span> F;span></span></code></pre> 是模糊且不严密的，需要重写才能用于自动解析器生成。具体来说，我们需要指定运算符的优先级（precedence）和结合性（associativity）。确定的语法如下所示：</p> class="giallo-l">Expr ::=</span></span> x2F;span> Factor</span></span> x2F;span> F;span> Atom</span></span> F;span> F;span></span> Expr ')'</span></span></code></pre> 的表述中完全消失了。此外，我花了三四门正式的语言课程</em>才能够自己可靠地创建这种语法。</p> 递归下降解析（recursive descent parsing）算法的增强，它使用优先级和结合性这种自然的术语来解析表达式，而不是语法混淆技术。</p> href="#递归下降和左递归" aria-label="Anchor link for: 递归下降和左递归">递归下降和左递归</a></h2> ，它将语法建模为一组相互递归的函数。例如，上面的 item 语法片段如下所示：</p> class="giallo-l">fn</span> item</span>(</span>p</span>: &</span>mut</span> Parser</span>) {</span></span> match</span> p</span>.</span>peek</span>() {</span></span> STRUCT_KEYWORD =></span> struct_item</span>(</span>p</span>),</span></span> ENUM_KEYWORD   =></span> enum_item</span>(</span>p</span>),</span></span> ...</span></span> pan> class="z-entity z-name z-function"> struct_item</span>(</span>p</span>: &</span>mut</span> Parser</span>) {</span></span> p</span>.</span>expect</span>(STRUCT_KEYWORD);</span></span> name</span>(</span>p</span>);</span></span> p</span>.</span>expect</span>(</span>L_CURLY</span>);</span></span> field_list</span>(</span>p</span>);</span></span> p</span>.</span>expect</span>(</span>R_CURLY</span>);</span></span> z-operator">...</span></span></code></pre> 方法的致命弱点，并利用这一缺点来引出更先进的 LR 解析技术。有问题的语法示例如下所示：</p> class="giallo-l">Sum ::=</span></span> Int</span></span> ;span></code></pre> 函数，它不会生效：</p> class="giallo-l">fn</span> sum</span>(</span>p</span>: &</span>mut</span> Parser</span>) {</span></span> // 尝试第一种情况</span></span> sum</span>(</span>p</span>);</span> // ➊</span></span> p</span>.</span>expect</span>(PLUS);</span></span> int</span>(</span>p</span>);</span></span> // 如果失败了，尝试其他情况</span></span> ...</span></span> </code></pre> 以消除左递归。然而在实践中，对于手写的解析器，解决方案要简单得多——摆脱纯粹的递归</em>范式并使用循环：</p> href="#Pratt_解析的大体结构" aria-label="Anchor link for: Pratt_解析的大体结构">Pratt 解析的大体结构</a></h2> 解析同时</em>使用循环和递归：</p> class="giallo-l">fn</span> parse_expr</span>() {</span></span> ...</span></span> loop</span> {</span></span> ...</span></span> parse_expr</span>()</span></span> ...</span></span> pan> </code></pre> 状的仓鼠轮，还能处理结合性和优先级！</p> ding_Power）">从优先级（Precedence）到绑定力（Binding Power）</a></h2> 优先级”感到困惑。在 a + b * c</code> 中，加法的优先级较低，但它位于解析树的顶部......</p> class="giallo-l">expr:   A       +       B       *       C</span></span> 5       5</span></span></code></pre> B</code> 和 C</code> 结合在一起，因此表达式被解析为 A + (B * C)</code>。</p> + B + C</code> 中，所有运算符似乎都具有相同的绑定力，并且不清楚首先折叠哪个 +</code> 。但如果我们让它稍微不对称的话，这也可以用绑定力来建模：</p> class="giallo-l">expr:      A       +       B       +       C</span></span> 3.1      3      3.1     0</span></span></code></pre> 右侧的绑定力，以便它更紧密地结合右操作数。我们还在两端添加了零，因为两侧没有要绑定的运算符。在这里，第一个（并且只有第一个）+</code> 比相邻运算符的更紧密地结合其两个操作数，因此我们可以折叠它：</p> > 0，其被第一个 +</code> 吸引，观察 B</code> 两侧，3.1 > 3，其也被第一个 +</code> 吸引。</p> class="giallo-l">expr:     (A + B)     +     C</span></span> 3    3.1    0</span></span></code></pre> (A + B) + C</code> 。或者，就语法树而言，第二个 +</code> 确实比起左侧操作数更喜欢右侧操作数，因此它急于结合 C。当它这样做时，第一个 +</code> 已经捕获了 A</code> 和 B</code>，因此没有争议。</p> 符串来找到这些比邻居运算符更强大的“坏蛋”。我们即将开始编写一些代码，但让我们首先看一下另一个可以运行的示例。我们将使用函数组合运算符 .</code>（点）作为具有高绑定力的右</em>结合运算符。即， f . g . h</code> 被解析为 f . (g . h)</code>，或者，其绑定力如下：</p> class="giallo-l">  f     .    g     .    h</span></span> 8   0</span></span></code></pre>
最小的 Pratt 解析器</a></h2> 字和变量作为基本原子，将标点符号作为操作符的表达式。让我们定义一个简单的词法解析器（tokenizer）：</p> class="giallo-l">#[derive(</span>Debug</span>,</span> Clone</span>,</span> Copy</span>,</span> PartialEq</span>,</span> Eq</span>)]</span></span> z-type">enum</span> Token</span> {</span></span> Atom</span>(</span>char</span>),</span></span> Op</span>(</span>char</span>),</span></span> Eof</span>,</span></span> z-type">struct</span> Lexer</span> {</span></span> tokens</span>:</span> Vec</span><</span>Token</span>>,</span></span> x2F;span> Lexer</span> {</span></span> fn</span> new</span>(</span>input</span>: &</span>str</span>) -></span> Lexer</span> {</span></span> z-type z-storage z-modifier">        let mut</span> tokens</span> =</span> input</span></span> .</span>chars</span>()</span></span> .</span>filter</span>(|</span>it</span>| !</span>it</span>.</span>is_ascii_whitespace</span>())</span></span> .</span>map</span>(|</span>c</span>|</span> match</span> c</span> {</span></span> '0'</span>..=</span>'9'</span> |</span></span> 'a'</span>..=</span>'z'</span> |</span> 'A'</span>..=</span>'Z'</span> =></span> Token</span>::</span>Atom</span>(</span>c</span>),</span></span> _</span> =></span> Token</span>::</span>Op</span>(</span>c</span>),</span></span> ></span> .</span>collect</span>::<</span>Vec</span><</span>_</span>>>();</span></span> tokens</span>.</span>reverse</span>();</span></span> Lexer</span> {</span> tokens</span> }</span></span> pan> fn</span> next</span>(&</span>mut self</span>) -></span> Token</span> {</span></span> self</span>.tokens.</span>pop</span>().</span>unwrap_or</span>(</span>Token</span>::</span>Eof</span>)</span></span> pan> fn</span> peek</span>(&</span>mut self</span>) -></span> Token</span> {</span></span> self</span>.tokens.</span>last</span>().</span>copied</span>().</span>unwrap_or</span>(</span>Token</span>::</span>Eof</span>)</span></span> pan> </code></pre> 2F;del>绑定力，我们将把中缀表达式转换为黄金标准（无论出于何种原因，在波兰不太流行）明确记号—— S-表达式（S-expressions）：1 + 2 * 3 == (+ 1 (* 2 3))</code>.</p> class="giallo-l">use</span> std</span>::fmt;</span></span> z-type">enum</span> S</span> {</span></span> Atom</span>(</span>char</span>),</span></span> Cons</span>(</span>char</span>,</span> Vec</span><</span>S</span>>),</span></span> x2F;span> fmt</span>::</span>Display</span> for</span> S</span> {</span></span> fn</span> fmt</span>(&</span>self</span>,</span> f</span>: &</span>mut</span> fmt</span>::</span>Formatter</span><'</span>_</span>>) -></span> fmt</span>::</span>Result</span> {</span></span> match</span> self</span> {</span></span> S</span>::</span>Atom</span>(</span>i</span>) =></span> write!</span>(</span>f</span>,</span> "{}"</span>,</span> i</span>),</span></span> S</span>::</span>Cons</span>(</span>head</span>,</span> rest</span>) => {</span></span> write!</span>(</span>f</span>,</span> "({}"</span>,</span> head</span>)?;</span></span> for</span> s</span> in</span> rest</span> {</span></span> write!</span>(</span>f</span>,</span> " {}"</span>,</span> s</span>)?</span></span> }</span></span> write!</span>(</span>f</span>,</span> ")"</span>)</span></span> </span> 2F;span> pan> </code></pre> 缀二元运算符 +</code> 和 *</code> 的表达式：</p> class="giallo-l">fn</span> expr</span>(</span>input</span>: &</span>str</span>) -></span> S</span> {</span></span> z-type z-storage z-modifier">    let mut</span> lexer</span> =</span> Lexer</span>::</span>new</span>(</span>input</span>);</span></span> expr_bp</span>(&</span>mut</span> lexer</span>)</span></span> class="z-entity z-name z-function"> expr_bp</span>(</span>lexer</span>: &</span>mut</span> Lexer</span>) -></span> S</span> {</span></span> todo!</span>()</span></span> ;span> class="z-entity z-name z-function"> tests</span>() {</span></span> let</span> s</span> =</span> expr</span>(</span>"1 + 2 * 3"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "(+ 1 (* 2 3))"</span>)</span></span> </code></pre> 上就是——从解析第一个数字开始，然后循环，消费运算符，然后……？</p> class="giallo-l">fn</span> expr_bp</span>(</span>lexer</span>: &</span>mut</span> Lexer</span>) -></span> S</span> {</span></span> let</span> lhs</span> =</span> match</span> lexer</span>.</span>next</span>() {</span></span> Token</span>::</span>Atom</span>(</span>it</span>) =></span> S</span>::</span>Atom</span>(</span>it</span>),</span></span> t</span> =></span> panic!</span>(</span>"bad token: {:?}"</span>,</span> t</span>),</span></span> span> loop</span> {</span></span> let</span> op</span> =</span> match</span> lexer</span>.</span>next</span>() {</span></span> Token</span>::</span>Eof</span> =></span> break</span>,</span></span> Token</span>::</span>Op</span>(</span>op</span>) =></span> op</span>,</span></span> t</span> =></span> panic!</span>(</span>"bad token: {:?}"</span>,</span> t</span>),</span></span> x2F;span> todo!</span>()</span></span> pan> lhs</span></span> ;span> class="z-entity z-name z-function"> tests</span>() {</span></span> let</span> s</span> =</span> expr</span>(</span>"1"</span>);</span> // ➊</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "1"</span>);</span></span> </code></pre> 让我们计算运算符的左绑定力和右绑定力。我们将使用 u8</code> 来表示绑定力，因此，为了表示结合性，我们将增加 1</code>。我们将为输入的末尾保留为 0</code> 绑定力，因此运算符可以拥有的最低绑定力是 1</code>。</p> *</code>、/</code> 都具有左结合性，因此其右侧的绑定力高于左侧，即 r_bp = l_bp + 1</code>。</p> class="giallo-l">fn</span> expr_bp</span>(</span>lexer</span>: &</span>mut</span> Lexer</span>) -></span> S</span> {</span></span> let</span> lhs</span> =</span> match</span> lexer</span>.</span>next</span>() {</span></span> Token</span>::</span>Atom</span>(</span>it</span>) =></span> S</span>::</span>Atom</span>(</span>it</span>),</span></span> t</span> =></span> panic!</span>(</span>"bad token: {:?}"</span>,</span> t</span>),</span></span> span> loop</span> {</span></span> let</span> op</span> =</span> match</span> lexer</span>.</span>peek</span>() {</span></span> Token</span>::</span>Eof</span> =></span> break</span>,</span></span> Token</span>::</span>Op</span>(</span>op</span>) =></span> op</span>,</span></span> t</span> =></span> panic!</span>(</span>"bad token: {:?}"</span>,</span> t</span>),</span></span> x2F;span> let</span> (</span>l_bp</span>,</span> r_bp</span>) =</span> infix_binding_power</span>(</span>op</span>);</span></span> todo!</span>()</span></span> pan> lhs</span></span> class="z-entity z-name z-function"> infix_binding_power</span>(</span>op</span>:</span> char</span>) -> (</span>u8</span>,</span> u8</span>) {</span></span> match</span> op</span> {</span></span> '+'</span> |</span> '-'</span> => (</span>1</span>,</span> 2</span>),</span></span> '*'</span> |</span> '/'</span> => (</span>3</span>,</span> 4</span>),</span></span> _</span> =></span> panic!</span>(</span>"bad op: {:?}"</span>)</span></span> pan> </code></pre> 。让我们考虑一下这个例子（具有以下绑定力）：</p> class="giallo-l">a   +   b   *   c   *   d   +   e</span></span> 3   4   1   2</span></span></code></pre> 们知道左边的 bp</code> 是 1</code>，右边的是 2</code>。lhs</code> 存储了 a</code>。+</code> 的后的下一个运算符是 *</code>，所以我们不应该将 b</code> 和 a</code> 相加。问题是我们还没有看到下一个运算符，我们只通过了 +</code> 号。那么我们可以添加一个 lookahead（译注：向前检视数个字符）吗？看起来不行——我们得通过所有的 b</code>、c</code> 和 d</code> 才能找到下一个具有较低绑定力的运算符，这听起来似乎没有边界。但我们发现了一些东西！我们当前的右优先级是 2</code>，为了能够折叠表达式，我们需要找到下一个具有较低优先级的运算符。所以让我们从 b</code> 开始递归调用 expr_bp</code>，但同时告诉它一旦 bp</code> 低于 2</code> 就停止。这需要在主函数中添加 min_bp</code> 参数。</p> class="giallo-l">fn</span> expr</span>(</span>input</span>: &</span>str</span>) -></span> S</span> {</span></span> z-type z-storage z-modifier">    let mut</span> lexer</span> =</span> Lexer</span>::</span>new</span>(</span>input</span>);</span></span> expr_bp</span>(&</span>mut</span> lexer</span>,</span> 0</span>)</span> // ❺</span></span> class="z-entity z-name z-function"> expr_bp</span>(</span>lexer</span>: &</span>mut</span> Lexer</span>,</span> min_bp</span>:</span> u8</span>) -></span> S</span> {</span> // ➊</span></span> z-type z-storage z-modifier">    let mut</span> lhs</span> =</span> match</span> lexer</span>.</span>next</span>() {</span></span> Token</span>::</span>Atom</span>(</span>it</span>) =></span> S</span>::</span>Atom</span>(</span>it</span>),</span></span> t</span> =></span> panic!</span>(</span>"bad token: {:?}"</span>,</span> t</span>),</span></span> span> loop</span> {</span></span> let</span> op</span> =</span> match</span> lexer</span>.</span>peek</span>() {</span></span> Token</span>::</span>Eof</span> =></span> break</span>,</span></span> Token</span>::</span>Op</span>(</span>op</span>) =></span> op</span>,</span></span> t</span> =></span> panic!</span>(</span>"bad token: {:?}"</span>,</span> t</span>),</span></span> x2F;span> let</span> (</span>l_bp</span>,</span> r_bp</span>) =</span> infix_binding_power</span>(</span>op</span>);</span></span> if</span> l_bp</span> <</span> min_bp</span> {</span> // ➋</span></span> break</span>;</span></span> 2F;span> lexer</span>.</span>next</span>();</span> // ❸</span></span> let</span> rhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> r_bp</span>);</span></span> lhs</span> =</span> S</span>::</span>Cons</span>(</span>op</span>,</span> vec!</span>[</span>lhs</span>,</span> rhs</span>]);</span> // ❹</span></span> pan> lhs</span></span> class="z-entity z-name z-function"> infix_binding_power</span>(</span>op</span>:</span> char</span>) -> (</span>u8</span>,</span> u8</span>) {</span></span> match</span> op</span> {</span></span> '+'</span> |</span> '-'</span> => (</span>1</span>,</span> 2</span>),</span></span> '*'</span> |</span> '/'</span> => (</span>3</span>,</span> 4</span>),</span></span> _</span> =></span> panic!</span>(</span>"bad op: {:?}"</span>),</span></span> pan> ;span> class="z-entity z-name z-function"> tests</span>() {</span></span> let</span> s</span> =</span> expr</span>(</span>"1"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "1"</span>);</span></span> let</span> s</span> =</span> expr</span>(</span>"1 + 2 * 3"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "(+ 1 (* 2 3))"</span>);</span></span> let</span> s</span> =</span> expr</span>(</span>"a + b * c * d + e"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "(+ (+ a (* (* b c) d)) e)"</span>);</span></span> </code></pre> expr_bp</code> 现在解析具有相对较高绑定力的表达式。一旦它发现比 min_bp</code> 绑定力弱的运算符，它就会停止。</li> 调用。注意我们如何使用 l_bp</code> 来检查 min_bp</code>，以及将 r_bp</code> 作为递归调用的新 min_bp</code>。因此，你可以将 min_bp</code> 看作是当前表达式左侧运算符的绑定力。</li> 装新的当前表达式。</li> 记住，在开始时左侧运算符的绑定力是最低的，即为零，因为那里实际上没有运算符。</li> 解析算法。它们很巧妙，但是，如果你理解它们，其他一切都是简单的添加。</p> href="#花哨的东西" aria-label="Anchor link for: 花哨的东西">花哨的东西</a></h2> 示算法的强大功能和灵活性。首先，我们添加一个高优先级的右结合函数复合运算符：.</code>：</p> class="giallo-l">fn</span> infix_binding_power</span>(</span>op</span>:</span> char</span>) -> (</span>u8</span>,</span> u8</span>) {</span></span> match</span> op</span> {</span></span> '+'</span> |</span> '-'</span> => (</span>1</span>,</span> 2</span>),</span></span> '*'</span> |</span> '/'</span> => (</span>3</span>,</span> 4</span>),</span></span> '.'</span> => (</span>6</span>,</span> 5</span>),</span></span> _</span> =></span> panic!</span>(</span>"bad op: {:?}"</span>),</span></span> pan> </code></pre> 绑定得更加紧密，这为我们提供了所需的右关联性：</p> class="giallo-l">let</span> s</span> =</span> expr</span>(</span>"f . g . h"</span>);</span></span> z-name z-function">assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "(. f (. g h))"</span>);</span></span> z-type">let</span> s</span> =</span> expr</span>(</span>" 1 + 2 + f . g . h * 3 * 4"</span>);</span></span> z-name z-function">assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "(+ (+ 1 2) (* (* (. f (. g h)) 3) 4))"</span>);</span></span></code></pre> 2F;code>，它的绑定比二元算术运算符更紧密，但不如组合紧密。这需要改变我们开始循环的方式，因为我们不再假设第一个标记是原子，并且还需要处理减号。但让类型来驱动我们吧。首先，我们从绑定力开始。由于这是一个一元运算符，它实际上只有右绑定力，所以，咳咳，让我们直接编写一下代码：</p> class="giallo-l">fn</span> prefix_binding_power</span>(</span>op</span>:</span> char</span>) -> ((),</span> u8</span>) {</span> // ➊</span></span> match</span> op</span> {</span></span> '+'</span> |</span> '-'</span> => ((),</span> 5</span>),</span></span> _</span> =></span> panic!</span>(</span>"bad op: {:?}"</span>,</span> op</span>),</span></span> pan> class="z-entity z-name z-function"> infix_binding_power</span>(</span>op</span>:</span> char</span>) -> (</span>u8</span>,</span> u8</span>) {</span></span> match</span> op</span> {</span></span> '+'</span> |</span> '-'</span> => (</span>1</span>,</span> 2</span>),</span></span> '*'</span> |</span> '/'</span> => (</span>3</span>,</span> 4</span>),</span></span> '.'</span> => (</span>8</span>,</span> 7</span>),</span> // ➋</span></span> _</span> =></span> panic!</span>(</span>"bad op: {:?}"</span>),</span></span> pan> </code></pre> ode>，以明确表示这是一个前缀运算符，而不是后缀运算符，因此只能绑定右侧的内容。</li> 和 *</code> 之间添加一元负号 -</code>，所以我们需要将 .</code> 的优先级提高两个等级。一般规则是我们使用奇数优先级作为基础，如果运算符是二元的，则通过一个单位来调整优先级。对于一元运算符负号 -</code> 来说，这无关紧要，我们可以使用 5</code> 或 6</code>，但使用奇数优先级会更一致。</li> ：</p> class="giallo-l">fn</span> expr_bp</span>(</span>lexer</span>: &</span>mut</span> Lexer</span>,</span> min_bp</span>:</span> u8</span>) -></span> S</span> {</span></span> z-type z-storage z-modifier">    let mut</span> lhs</span> =</span> match</span> lexer</span>.</span>next</span>() {</span></span> Token</span>::</span>Atom</span>(</span>it</span>) =></span> S</span>::</span>Atom</span>(</span>it</span>),</span></span> Token</span>::</span>Op</span>(</span>op</span>) => {</span></span> let</span> ((),</span> r_bp</span>) =</span> prefix_binding_power</span>(</span>op</span>);</span></span> todo!</span>()</span></span> 2F;span> t</span> =></span> panic!</span>(</span>"bad token: {:?}"</span>,</span> t</span>),</span></span> span> ...</span></span> </code></pre> 而没有 l_bp</code>，所以让我们只复制主循环中一半的代码？记住，我们在递归调用中使用 r_bp</code>。</p> class="giallo-l">fn</span> expr_bp</span>(</span>lexer</span>: &</span>mut</span> Lexer</span>,</span> min_bp</span>:</span> u8</span>) -></span> S</span> {</span></span> z-type z-storage z-modifier">    let mut</span> lhs</span> =</span> match</span> lexer</span>.</span>next</span>() {</span></span> Token</span>::</span>Atom</span>(</span>it</span>) =></span> S</span>::</span>Atom</span>(</span>it</span>),</span></span> Token</span>::</span>Op</span>(</span>op</span>) => {</span></span> let</span> ((),</span> r_bp</span>) =</span> prefix_binding_power</span>(</span>op</span>);</span></span> let</span> rhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> r_bp</span>);</span></span> S</span>::</span>Cons</span>(</span>op</span>,</span> vec!</span>[</span>rhs</span>])</span></span> 2F;span> t</span> =></span> panic!</span>(</span>"bad token: {:?}"</span>,</span> t</span>),</span></span> span> loop</span> {</span></span> let</span> op</span> =</span> match</span> lexer</span>.</span>peek</span>() {</span></span> Token</span>::</span>Eof</span> =></span> break</span>,</span></span> Token</span>::</span>Op</span>(</span>op</span>) =></span> op</span>,</span></span> t</span> =></span> panic!</span>(</span>"bad token: {:?}"</span>,</span> t</span>),</span></span> x2F;span> let</span> (</span>l_bp</span>,</span> r_bp</span>) =</span> infix_binding_power</span>(</span>op</span>);</span></span> if</span> l_bp</span> <</span> min_bp</span> {</span></span> break</span>;</span></span> 2F;span> lexer</span>.</span>next</span>();</span></span> let</span> rhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> r_bp</span>);</span></span> lhs</span> =</span> S</span>::</span>Cons</span>(</span>op</span>,</span> vec!</span>[</span>lhs</span>,</span> rhs</span>]);</span></span> pan> lhs</span></span> ;span> class="z-entity z-name z-function"> tests</span>() {</span></span> ...</span></span> let</span> s</span> =</span> expr</span>(</span>"--1 * 2"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "(* (- (- 1)) 2)"</span>);</span></span> let</span> s</span> =</span> expr</span>(</span>"--f . g"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "(- (- (. f g)))"</span>);</span></span> </code></pre> 的转换是有效的。当然，你也可以推理出它为什么有效。同样的论点也适用于：在我们处理了一个前缀运算符后，操作数由绑定得更加紧密的的运算符组成，而我们恰好有一个函数可以解析比指定优先级更加紧密的表达式。</p> ((), u8)</code> 对前缀运算符“正好奏效”，那么 (u8, ())</code> 能处理后缀运算符吗？好，让我们添加 !</code> 作为阶乘运算符。它应该比 -</code> 绑定得更紧，因为 -(92!)</code> 显然比 (-92)!</code> 更有用。所以，熟悉的流程——新的优先级函数，调整 .</code> 的优先级（这一点在 Pratt 解析器中确实很烦人），复制粘贴代码...</p> class="giallo-l">let</span> (</span>l_bp</span>, ()) =</span> postfix_binding_power</span>(</span>op</span>);</span></span> z-control">if</span> l_bp</span> <</span> min_bp</span> {</span></span> break</span>;</span></span> z-type">let</span> (</span>l_bp</span>,</span> r_bp</span>) =</span> infix_binding_power</span>(</span>op</span>);</span></span> z-control">if</span> l_bp</span> <</span> min_bp</span> {</span></span> break</span>;</span></span> </code></pre> 表达式之后，我们可能会看到一个后缀或中缀运算符。但是我们在遇到未识别的运算符时会退出，这样是行不通的……所以，我们让 postfix_binding_power</code> 返回一个 option，以便在运算符不是后缀的情况下处理：</p> class="giallo-l">fn</span> expr_bp</span>(</span>lexer</span>: &</span>mut</span> Lexer</span>,</span> min_bp</span>:</span> u8</span>) -></span> S</span> {</span></span> z-type z-storage z-modifier">    let mut</span> lhs</span> =</span> match</span> lexer</span>.</span>next</span>() {</span></span> Token</span>::</span>Atom</span>(</span>it</span>) =></span> S</span>::</span>Atom</span>(</span>it</span>),</span></span> Token</span>::</span>Op</span>(</span>op</span>) => {</span></span> let</span> ((),</span> r_bp</span>) =</span> prefix_binding_power</span>(</span>op</span>);</span></span> let</span> rhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> r_bp</span>);</span></span> S</span>::</span>Cons</span>(</span>op</span>,</span> vec!</span>[</span>rhs</span>])</span></span> 2F;span> t</span> =></span> panic!</span>(</span>"bad token: {:?}"</span>,</span> t</span>),</span></span> span> loop</span> {</span></span> let</span> op</span> =</span> match</span> lexer</span>.</span>peek</span>() {</span></span> Token</span>::</span>Eof</span> =></span> break</span>,</span></span> Token</span>::</span>Op</span>(</span>op</span>) =></span> op</span>,</span></span> t</span> =></span> panic!</span>(</span>"bad token: {:?}"</span>,</span> t</span>),</span></span> x2F;span> if</span> let</span> Some</span>((</span>l_bp</span>, ())) =</span> postfix_binding_power</span>(</span>op</span>) {</span></span> if</span> l_bp</span> <</span> min_bp</span> {</span></span> break</span>;</span></span> }</span></span> lexer</span>.</span>next</span>();</span></span> lhs</span> =</span> S</span>::</span>Cons</span>(</span>op</span>,</span> vec!</span>[</span>lhs</span>]);</span></span> continue</span>;</span></span> ></span> let</span> (</span>l_bp</span>,</span> r_bp</span>) =</span> infix_binding_power</span>(</span>op</span>);</span></span> if</span> l_bp</span> <</span> min_bp</span> {</span></span> break</span>;</span></span> 2F;span> lexer</span>.</span>next</span>();</span></span> let</span> rhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> r_bp</span>);</span></span> lhs</span> =</span> S</span>::</span>Cons</span>(</span>op</span>,</span> vec!</span>[</span>lhs</span>,</span> rhs</span>]);</span></span> pan> lhs</span></span> class="z-entity z-name z-function"> prefix_binding_power</span>(</span>op</span>:</span> char</span>) -> ((),</span> u8</span>) {</span></span> match</span> op</span> {</span></span> '+'</span> |</span> '-'</span> => ((),</span> 5</span>),</span></span> _</span> =></span> panic!</span>(</span>"bad op: {:?}"</span>,</span> op</span>),</span></span> pan> </span> postfix_binding_power</span>(</span>op</span>:</span> char</span>) -></span> Option</span><(</span>u8</span>, ())> {</span></span> let</span> res</span> =</span> match</span> op</span> {</span></span> '!'</span> => (</span>7</span>, ()),</span></span> _</span> =></span> return</span> None</span>,</span></span> #x2F;span> Some</span>(</span>res</span>)</span></span> span> class="z-entity z-name z-function"> infix_binding_power</span>(</span>op</span>:</span> char</span>) -> (</span>u8</span>,</span> u8</span>) {</span></span> match</span> op</span> {</span></span> '+'</span> |</span> '-'</span> => (</span>1</span>,</span> 2</span>),</span></span> '*'</span> |</span> '/'</span> => (</span>3</span>,</span> 4</span>),</span></span> '.'</span> => (</span>10</span>,</span> 9</span>),</span></span> _</span> =></span> panic!</span>(</span>"bad op: {:?}"</span>),</span></span> pan> ;span> class="z-entity z-name z-function"> tests</span>() {</span></span> let</span> s</span> =</span> expr</span>(</span>"-9!"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "(- (! 9))"</span>);</span></span> let</span> s</span> =</span> expr</span>(</span>"f . g !"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "(! (. f g))"</span>);</span></span> </code></pre> 括号表达式。实际上，这并不难，我们本来可以从一开始就做到这一点，但在这里处理这个问题是有意义的，稍后你就会明白为什么。括号只是一个 primary 表达式，其处理方式与原子类似：</p> class="giallo-l">let mut</span> lhs</span> =</span> match</span> lexer</span>.</span>next</span>() {</span></span> Token</span>::</span>Atom</span>(</span>it</span>) =></span> S</span>::</span>Atom</span>(</span>it</span>),</span></span> Token</span>::</span>Op</span>(</span>'('</span>) => {</span></span> let</span> lhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> 0</span>);</span></span> assert_eq!</span>(</span>lexer</span>.</span>next</span>(),</span> Token</span>::</span>Op</span>(</span>')'</span>));</span></span> lhs</span></span> pan> Token</span>::</span>Op</span>(</span>op</span>) => {</span></span> let</span> ((),</span> r_bp</span>) =</span> prefix_binding_power</span>(</span>op</span>);</span></span> let</span> rhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> r_bp</span>);</span></span> S</span>::</span>Cons</span>(</span>op</span>,</span> vec!</span>[</span>rhs</span>])</span></span> pan> t</span> =></span> panic!</span>(</span>"bad token: {:?}"</span>,</span> t</span>),</span></span> ></code></pre> class="giallo-l">let</span> s</span> =</span> expr</span>(</span>"(((0)))"</span>);</span></span> z-name z-function">assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "0"</span>);</span></span></code></pre> 止条件是到达 eof，而 )</code> 显然不是 eof。修复这个问题的最简单方法是让 infix_binding_power</code> 在遇到未识别的操作数时返回 None</code>。这样，它将也变得类似于 postfix_binding_power</code>！</p> class="giallo-l">fn</span> expr_bp</span>(</span>lexer</span>: &</span>mut</span> Lexer</span>,</span> min_bp</span>:</span> u8</span>) -></span> S</span> {</span></span> z-type z-storage z-modifier">    let mut</span> lhs</span> =</span> match</span> lexer</span>.</span>next</span>() {</span></span> Token</span>::</span>Atom</span>(</span>it</span>) =></span> S</span>::</span>Atom</span>(</span>it</span>),</span></span> Token</span>::</span>Op</span>(</span>'('</span>) => {</span></span> let</span> lhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> 0</span>);</span></span> z-name z-function">            assert_eq!</span>(</span>lexer</span>.</span>next</span>(),</span> Token</span>::</span>Op</span>(</span>')'</span>));</span></span> lhs</span></span> ></span> Token</span>::</span>Op</span>(</span>op</span>) => {</span></span> let</span> ((),</span> r_bp</span>) =</span> prefix_binding_power</span>(</span>op</span>);</span></span> let</span> rhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> r_bp</span>);</span></span> S</span>::</span>Cons</span>(</span>op</span>,</span> vec!</span>[</span>rhs</span>])</span></span> 2F;span> t</span> =></span> panic!</span>(</span>"bad token: {:?}"</span>,</span> t</span>),</span></span> span> loop</span> {</span></span> let</span> op</span> =</span> match</span> lexer</span>.</span>peek</span>() {</span></span> Token</span>::</span>Eof</span> =></span> break</span>,</span></span> Token</span>::</span>Op</span>(</span>op</span>) =></span> op</span>,</span></span> t</span> =></span> panic!</span>(</span>"bad token: {:?}"</span>,</span> t</span>),</span></span> x2F;span> if</span> let</span> Some</span>((</span>l_bp</span>, ())) =</span> postfix_binding_power</span>(</span>op</span>) {</span></span> if</span> l_bp</span> <</span> min_bp</span> {</span></span> break</span>;</span></span> </span> lexer</span>.</span>next</span>();</span></span> lhs</span> =</span> S</span>::</span>Cons</span>(</span>op</span>,</span> vec!</span>[</span>lhs</span>]);</span></span> continue</span>;</span></span> 2F;span> if</span> let</span> Some</span>((</span>l_bp</span>,</span> r_bp</span>)) =</span> infix_binding_power</span>(</span>op</span>) {</span></span> if</span> l_bp</span> <</span> min_bp</span> {</span></span> break</span>;</span></span> }</span></span> lexer</span>.</span>next</span>();</span></span> let</span> rhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> r_bp</span>);</span></span> lhs</span> =</span> S</span>::</span>Cons</span>(</span>op</span>,</span> vec!</span>[</span>lhs</span>,</span> rhs</span>]);</span></span> continue</span>;</span></span> ></span> break</span>;</span></span> pan> lhs</span></span> class="z-entity z-name z-function"> prefix_binding_power</span>(</span>op</span>:</span> char</span>) -> ((),</span> u8</span>) {</span></span> match</span> op</span> {</span></span> '+'</span> |</span> '-'</span> => ((),</span> 5</span>),</span></span> _</span> =></span> panic!</span>(</span>"bad op: {:?}"</span>,</span> op</span>),</span></span> pan> class="z-entity z-name z-function"> postfix_binding_power</span>(</span>op</span>:</span> char</span>) -></span> Option</span><(</span>u8</span>, ())> {</span></span> let</span> res</span> =</span> match</span> op</span> {</span></span> '!'</span> => (</span>7</span>, ()),</span></span> _</span> =></span> return</span> None</span>,</span></span> span> Some</span>(</span>res</span>)</span></span> </span> infix_binding_power</span>(</span>op</span>:</span> char</span>) -></span> Option</span><(</span>u8</span>,</span> u8</span>)> {</span></span> let</span> res</span> =</span> match</span> op</span> {</span></span> '+'</span> |</span> '-'</span> => (</span>1</span>,</span> 2</span>),</span></span> '*'</span> |</span> '/'</span> => (</span>3</span>,</span> 4</span>),</span></span> '.'</span> => (</span>10</span>,</span> 9</span>),</span></span> _</span> =></span> return</span> None</span>,</span></span> #x2F;span> Some</span>(</span>res</span>)</span></span> span></code></pre> a[i]</code>。它是什么类型的运算符？周围类型？如果只是 a[]</code>，它显然是后缀的。如果只是 [i]</code>，它会像括号一样工作。关键在于：i</code> 部分实际上并不参与整个绑定力游戏，因为它有明确的范围。因此，我们可以这样做：</p> class="giallo-l">fn</span> expr_bp</span>(</span>lexer</span>: &</span>mut</span> Lexer</span>,</span> min_bp</span>:</span> u8</span>) -></span> S</span> {</span></span> z-type z-storage z-modifier">    let mut</span> lhs</span> =</span> match</span> lexer</span>.</span>next</span>() {</span></span> Token</span>::</span>Atom</span>(</span>it</span>) =></span> S</span>::</span>Atom</span>(</span>it</span>),</span></span> Token</span>::</span>Op</span>(</span>'('</span>) => {</span></span> let</span> lhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> 0</span>);</span></span> assert_eq!</span>(</span>lexer</span>.</span>next</span>(),</span> Token</span>::</span>Op</span>(</span>')'</span>));</span></span> lhs</span></span> 2F;span> Token</span>::</span>Op</span>(</span>op</span>) => {</span></span> let</span> ((),</span> r_bp</span>) =</span> prefix_binding_power</span>(</span>op</span>);</span></span> let</span> rhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> r_bp</span>);</span></span> S</span>::</span>Cons</span>(</span>op</span>,</span> vec!</span>[</span>rhs</span>])</span></span> 2F;span> t</span> =></span> panic!</span>(</span>"bad token: {:?}"</span>,</span> t</span>),</span></span> span> loop</span> {</span></span> let</span> op</span> =</span> match</span> lexer</span>.</span>peek</span>() {</span></span> Token</span>::</span>Eof</span> =></span> break</span>,</span></span> Token</span>::</span>Op</span>(</span>op</span>) =></span> op</span>,</span></span> t</span> =></span> panic!</span>(</span>"bad token: {:?}"</span>,</span> t</span>),</span></span> x2F;span> if</span> let</span> Some</span>((</span>l_bp</span>, ())) =</span> postfix_binding_power</span>(</span>op</span>) {</span></span> if</span> l_bp</span> <</span> min_bp</span> {</span></span> break</span>;</span></span> </span> lexer</span>.</span>next</span>();</span></span> lhs</span> =</span> if</span> op</span> ==</span> '['</span> {</span></span> let</span> rhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> 0</span>);</span></span> z-name z-function">                assert_eq!</span>(</span>lexer</span>.</span>next</span>(),</span> Token</span>::</span>Op</span>(</span>']'</span>));</span></span> S</span>::</span>Cons</span>(</span>op</span>,</span> vec!</span>[</span>lhs</span>,</span> rhs</span>])</span></span> }</span> else</span> {</span></span> S</span>::</span>Cons</span>(</span>op</span>,</span> vec!</span>[</span>lhs</span>])</span></span> };</span></span> continue</span>;</span></span> 2F;span> if</span> let</span> Some</span>((</span>l_bp</span>,</span> r_bp</span>)) =</span> infix_binding_power</span>(</span>op</span>) {</span></span> if</span> l_bp</span> <</span> min_bp</span> {</span></span> break</span>;</span></span> </span> lexer</span>.</span>next</span>();</span></span> let</span> rhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> r_bp</span>);</span></span> lhs</span> =</span> S</span>::</span>Cons</span>(</span>op</span>,</span> vec!</span>[</span>lhs</span>,</span> rhs</span>]);</span></span> continue</span>;</span></span> 2F;span> break</span>;</span></span> pan> lhs</span></span> class="z-entity z-name z-function"> prefix_binding_power</span>(</span>op</span>:</span> char</span>) -> ((),</span> u8</span>) {</span></span> match</span> op</span> {</span></span> '+'</span> |</span> '-'</span> => ((),</span> 5</span>),</span></span> _</span> =></span> panic!</span>(</span>"bad op: {:?}"</span>,</span> op</span>),</span></span> pan> class="z-entity z-name z-function"> postfix_binding_power</span>(</span>op</span>:</span> char</span>) -></span> Option</span><(</span>u8</span>, ())> {</span></span> let</span> res</span> =</span> match</span> op</span> {</span></span> '!'</span> |</span> '['</span> => (</span>7</span>, ()),</span> // ➊</span></span> _</span> =></span> return</span> None</span>,</span></span> span> Some</span>(</span>res</span>)</span></span> class="z-entity z-name z-function"> infix_binding_power</span>(</span>op</span>:</span> char</span>) -></span> Option</span><(</span>u8</span>,</span> u8</span>)> {</span></span> let</span> res</span> =</span> match</span> op</span> {</span></span> '+'</span> |</span> '-'</span> => (</span>1</span>,</span> 2</span>),</span></span> '*'</span> |</span> '/'</span> => (</span>3</span>,</span> 4</span>),</span></span> '.'</span> => (</span>10</span>,</span> 9</span>),</span></span> _</span> =></span> return</span> None</span>,</span></span> span> Some</span>(</span>res</span>)</span></span> ;span> class="z-entity z-name z-function"> tests</span>() {</span></span> ...</span></span> let</span> s</span> =</span> expr</span>(</span>"x[0][1]"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "([ ([ x 0) 1)"</span>);</span></span> </code></pre> [</code> 使用了相同的优先级。一般来说，为了算法的正确性，在做决策时，优先级永远不能相等。否则，我们可能会遇到类似之前的小调整中的情况，那时有两个同样合适的折叠候选项。然而，我们只比较右侧的 bp</code> 和左侧的 bp</code>！因此，对于两个后缀运算符，它们具有相同的优先级是可以的，因为它们都是右侧的。</li> class="giallo-l">c ? e1 : e2</span></span></code></pre> 吗？好吧，让我们稍微改变一下三元运算符的语法：</p> class="giallo-l">c [ e1 ] e2</span></span></code></pre> 被认为是一个后缀运算符 + 括号的组合……所以，?</code> 和 :</code> 实际上是一对奇特的括号！让我们这样处理它们吧！现在，优先级和结合性呢？在这种情况下，结合性到底是什么？</p> class="giallo-l">a ? b : c ? d : e</span></span></code></pre> class="giallo-l">a ?: c ?: e</span></span></code></pre> class="giallo-l">(a ?: c) ?: e</span></span></code></pre> class="giallo-l">a</span> ?: (</span>c</span> ?:</span> e</span>)</span></span></code></pre> 链：</p> class="giallo-l">a ? b :</span></span> ;span> </code></pre> 三元运算符优先级较低。在 C 语言中，只有 =</code> 和 ,</code> 的优先级更低。既然提到这里了，我们也添加上 C 语言风格的右结合 =</code>。</p> class="giallo-l">use</span> std</span>::{fmt,</span> io</span>::</span>BufRead</span>};</span></span> z-type">enum</span> S</span> {</span></span> Atom</span>(</span>char</span>),</span></span> Cons</span>(</span>char</span>,</span> Vec</span><</span>S</span>>),</span></span> x2F;span> fmt</span>::</span>Display</span> for</span> S</span> {</span></span> fn</span> fmt</span>(&</span>self</span>,</span> f</span>: &</span>mut</span> fmt</span>::</span>Formatter</span><'</span>_</span>>) -></span> fmt</span>::</span>Result</span> {</span></span> match</span> self</span> {</span></span> S</span>::</span>Atom</span>(</span>i</span>) =></span> write!</span>(</span>f</span>,</span> "{}"</span>,</span> i</span>),</span></span> S</span>::</span>Cons</span>(</span>head</span>,</span> rest</span>) => {</span></span> write!</span>(</span>f</span>,</span> "({}"</span>,</span> head</span>)?;</span></span> for</span> s</span> in</span> rest</span> {</span></span> write!</span>(</span>f</span>,</span> " {}"</span>,</span> s</span>)?</span></span> }</span></span> write!</span>(</span>f</span>,</span> ")"</span>)</span></span> </span> 2F;span> pan> class="z-entity z-name z-type">Debug</span>,</span> Clone</span>,</span> Copy</span>,</span> PartialEq</span>,</span> Eq</span>)]</span></span> z-type">enum</span> Token</span> {</span></span> Atom</span>(</span>char</span>),</span></span> Op</span>(</span>char</span>),</span></span> Eof</span>,</span></span> z-type">struct</span> Lexer</span> {</span></span> tokens</span>:</span> Vec</span><</span>Token</span>>,</span></span> x2F;span> Lexer</span> {</span></span> fn</span> new</span>(</span>input</span>: &</span>str</span>) -></span> Lexer</span> {</span></span> z-type z-storage z-modifier">        let mut</span> tokens</span> =</span> input</span></span> .</span>chars</span>()</span></span> .</span>filter</span>(|</span>it</span>| !</span>it</span>.</span>is_ascii_whitespace</span>())</span></span> .</span>map</span>(|</span>c</span>|</span> match</span> c</span> {</span></span> '0'</span>..=</span>'9'</span></span> |</span> 'a'</span>..=</span>'z'</span> |</span> 'A'</span>..=</span>'Z'</span> =></span> Token</span>::</span>Atom</span>(</span>c</span>),</span></span> _</span> =></span> Token</span>::</span>Op</span>(</span>c</span>),</span></span> ></span> .</span>collect</span>::<</span>Vec</span><</span>_</span>>>();</span></span> tokens</span>.</span>reverse</span>();</span></span> Lexer</span> {</span> tokens</span> }</span></span> pan> fn</span> next</span>(&</span>mut self</span>) -></span> Token</span> {</span></span> self</span>.tokens.</span>pop</span>().</span>unwrap_or</span>(</span>Token</span>::</span>Eof</span>)</span></span> pan> fn</span> peek</span>(&</span>mut self</span>) -></span> Token</span> {</span></span> self</span>.tokens.</span>last</span>().</span>copied</span>().</span>unwrap_or</span>(</span>Token</span>::</span>Eof</span>)</span></span> pan> class="z-entity z-name z-function"> expr</span>(</span>input</span>: &</span>str</span>) -></span> S</span> {</span></span> z-type z-storage z-modifier">    let mut</span> lexer</span> =</span> Lexer</span>::</span>new</span>(</span>input</span>);</span></span> expr_bp</span>(&</span>mut</span> lexer</span>,</span> 0</span>)</span></span> class="z-entity z-name z-function"> expr_bp</span>(</span>lexer</span>: &</span>mut</span> Lexer</span>,</span> min_bp</span>:</span> u8</span>) -></span> S</span> {</span></span> z-type z-storage z-modifier">    let mut</span> lhs</span> =</span> match</span> lexer</span>.</span>next</span>() {</span></span> Token</span>::</span>Atom</span>(</span>it</span>) =></span> S</span>::</span>Atom</span>(</span>it</span>),</span></span> Token</span>::</span>Op</span>(</span>'('</span>) => {</span></span> let</span> lhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> 0</span>);</span></span> assert_eq!</span>(</span>lexer</span>.</span>next</span>(),</span> Token</span>::</span>Op</span>(</span>')'</span>));</span></span> lhs</span></span> 2F;span> Token</span>::</span>Op</span>(</span>op</span>) => {</span></span> let</span> ((),</span> r_bp</span>) =</span> prefix_binding_power</span>(</span>op</span>);</span></span> let</span> rhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> r_bp</span>);</span></span> S</span>::</span>Cons</span>(</span>op</span>,</span> vec!</span>[</span>rhs</span>])</span></span> 2F;span> t</span> =></span> panic!</span>(</span>"bad token: {:?}"</span>,</span> t</span>),</span></span> span> loop</span> {</span></span> let</span> op</span> =</span> match</span> lexer</span>.</span>peek</span>() {</span></span> Token</span>::</span>Eof</span> =></span> break</span>,</span></span> Token</span>::</span>Op</span>(</span>op</span>) =></span> op</span>,</span></span> t</span> =></span> panic!</span>(</span>"bad token: {:?}"</span>,</span> t</span>),</span></span> x2F;span> if</span> let</span> Some</span>((</span>l_bp</span>, ())) =</span> postfix_binding_power</span>(</span>op</span>) {</span></span> if</span> l_bp</span> <</span> min_bp</span> {</span></span> break</span>;</span></span> </span> lexer</span>.</span>next</span>();</span></span> lhs</span> =</span> if</span> op</span> ==</span> '['</span> {</span></span> let</span> rhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> 0</span>);</span></span> assert_eq!</span>(</span>lexer</span>.</span>next</span>(),</span> Token</span>::</span>Op</span>(</span>']'</span>));</span></span> S</span>::</span>Cons</span>(</span>op</span>,</span> vec!</span>[</span>lhs</span>,</span> rhs</span>])</span></span> class="z-keyword z-control"> else</span> {</span></span> S</span>::</span>Cons</span>(</span>op</span>,</span> vec!</span>[</span>lhs</span>])</span></span> ></span> continue</span>;</span></span> 2F;span> if</span> let</span> Some</span>((</span>l_bp</span>,</span> r_bp</span>)) =</span> infix_binding_power</span>(</span>op</span>) {</span></span> if</span> l_bp</span> <</span> min_bp</span> {</span></span> break</span>;</span></span> </span> lexer</span>.</span>next</span>();</span></span> lhs</span> =</span> if</span> op</span> ==</span> '?'</span> {</span></span> let</span> mhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> 0</span>);</span></span> assert_eq!</span>(</span>lexer</span>.</span>next</span>(),</span> Token</span>::</span>Op</span>(</span>':'</span>));</span></span> let</span> rhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> r_bp</span>);</span></span> S</span>::</span>Cons</span>(</span>op</span>,</span> vec!</span>[</span>lhs</span>,</span> mhs</span>,</span> rhs</span>])</span></span> class="z-keyword z-control"> else</span> {</span></span> let</span> rhs</span> =</span> expr_bp</span>(</span>lexer</span>,</span> r_bp</span>);</span></span> S</span>::</span>Cons</span>(</span>op</span>,</span> vec!</span>[</span>lhs</span>,</span> rhs</span>])</span></span> ></span> continue</span>;</span></span> 2F;span> break</span>;</span></span> pan> lhs</span></span> class="z-entity z-name z-function"> prefix_binding_power</span>(</span>op</span>:</span> char</span>) -> ((),</span> u8</span>) {</span></span> match</span> op</span> {</span></span> '+'</span> |</span> '-'</span> => ((),</span> 9</span>),</span></span> _</span> =></span> panic!</span>(</span>"bad op: {:?}"</span>,</span> op</span>),</span></span> pan> class="z-entity z-name z-function"> postfix_binding_power</span>(</span>op</span>:</span> char</span>) -></span> Option</span><(</span>u8</span>, ())> {</span></span> let</span> res</span> =</span> match</span> op</span> {</span></span> '!'</span> => (</span>11</span>, ()),</span></span> '['</span> => (</span>11</span>, ()),</span></span> _</span> =></span> return</span> None</span>,</span></span> span> Some</span>(</span>res</span>)</span></span> class="z-entity z-name z-function"> infix_binding_power</span>(</span>op</span>:</span> char</span>) -></span> Option</span><(</span>u8</span>,</span> u8</span>)> {</span></span> let</span> res</span> =</span> match</span> op</span> {</span></span> '='</span> => (</span>2</span>,</span> 1</span>),</span></span> '?'</span> => (</span>4</span>,</span> 3</span>),</span></span> '+'</span> |</span> '-'</span> => (</span>5</span>,</span> 6</span>),</span></span> '*'</span> |</span> '/'</span> => (</span>7</span>,</span> 8</span>),</span></span> '.'</span> => (</span>14</span>,</span> 13</span>),</span></span> _</span> =></span> return</span> None</span>,</span></span> span> Some</span>(</span>res</span>)</span></span> ;span> class="z-entity z-name z-function"> tests</span>() {</span></span> let</span> s</span> =</span> expr</span>(</span>"1"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "1"</span>);</span></span> let</span> s</span> =</span> expr</span>(</span>"1 + 2 * 3"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "(+ 1 (* 2 3))"</span>);</span></span> let</span> s</span> =</span> expr</span>(</span>"a + b * c * d + e"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "(+ (+ a (* (* b c) d)) e)"</span>);</span></span> let</span> s</span> =</span> expr</span>(</span>"f . g . h"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "(. f (. g h))"</span>);</span></span> let</span> s</span> =</span> expr</span>(</span>" 1 + 2 + f . g . h * 3 * 4"</span>);</span></span> assert_eq!</span>(</span></span> s</span>.</span>to_string</span>(),</span></span> "(+ (+ 1 2) (* (* (. f (. g h)) 3) 4))"</span>,</span></span> span> let</span> s</span> =</span> expr</span>(</span>"--1 * 2"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "(* (- (- 1)) 2)"</span>);</span></span> let</span> s</span> =</span> expr</span>(</span>"--f . g"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "(- (- (. f g)))"</span>);</span></span> let</span> s</span> =</span> expr</span>(</span>"-9!"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "(- (! 9))"</span>);</span></span> let</span> s</span> =</span> expr</span>(</span>"f . g !"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "(! (. f g))"</span>);</span></span> let</span> s</span> =</span> expr</span>(</span>"(((0)))"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "0"</span>);</span></span> let</span> s</span> =</span> expr</span>(</span>"x[0][1]"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "([ ([ x 0) 1)"</span>);</span></span> let</span> s</span> =</span> expr</span>(</span></span> "a ? b :</span></span> c ? d</span></span> : e"</span>,</span></span> span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "(? a b (? c d e))"</span>);</span></span> let</span> s</span> =</span> expr</span>(</span>"a = 0 ? b : c = d"</span>);</span></span> assert_eq!</span>(</span>s</span>.</span>to_string</span>(),</span> "(= a (= (? 0 b c) d))"</span>)</span></span> class="z-entity z-name z-function"> main</span>() {</span></span> for</span> line</span> in</span> std</span>::</span>io</span>::</span>stdin</span>().</span>lock</span>().</span>lines</span>() {</span></span> let</span> line</span> =</span> line</span>.</span>unwrap</span>();</span></span> let</span> s</span> =</span> expr</span>(&</span>line</span>);</span></span> println!</span>(</span>"{}"</span>,</span> s</span>)</span></span> pan> </code></pre> noreferrer external" target="_blank" href="https://github.com/matklad/minipratt">这个仓库</a>中找到，Eof :-)</p>
这篇是上篇</a>的续集。</p>
最近要交论文终稿了，学校的通知也说明了需要提交 PDF 格式的论文，那么看起来我没有不使用 Typst 的理由了。</p>
所以，这次我打算把我的论文写作工作流切换到使用 Markdown + Pandoc + Typst。</p>
首先，有一个问题是，我为什么仍然使用 Markdown 转换为 Typst 而非直接使用 Typst 呢？</p>
理由主要有以下两点：</p>

Markdown 的生态更加完善。Markdown 有大量配套工具，而 Typst 则尚且不完善。比如我常用的 Prettier 用于 formatter，markdown-lint 用于 linter。这些在 Typst 中都暂时不存在替代品。并且，虽然 Typst 可以做到实时预览 PDF，但是却无法做到定位当前编辑的位置，当我修改了 Typst 文件后，PDF 会回到文件开头，也无法做到跟随滚动。</li>
Markdown 是一种很好的中间语言。Markdown 可以很方便的转化为任何一种标记语言，它就像是一种所有标记语言的交集，如果未来我希望把我的论文发布在网络上，或者转化为其它语言，Markdown 就可以很方便的做到。</li>
</ol>
那么，开始我们的 Markdown to Typst 论文写作之旅吧。</p>
开始</a></h2>
首先，需要安装 Pandoc</a> 和 Typst</a>。</p>
# For macOS</span></span>
brew</span> install pandoc typst</span></span>
</span>
# For Arch</span></span>
pacman</span> -S</span> pandoc typst</span></span>
</span>
# For deb</span></span>
apt</span> install pandoc typst</span></span></code></pre>
一图胜千言，下面是整个 Markdown to Typst 需要用到的文件和工作流：</p>

</th>	'a</th>	T</th>	U</th></tr></thead>
`&'a T</code></td>`	协变</td>	协变</td>	</td></tr>
`&'a mut T</code></td>`	协变</td>	不变</td>	</td></tr>
`Box<T></code></td>`	</td>	协变</td>	</td></tr>
`Vec<T></code></td>`	</td>	协变</td>	</td></tr>
`UnsafeCell<T></code></td>`	</td>	不变</td>	</td></tr>
`Cell<T></code></td>`	</td>	不变</td>	</td></tr>
`fn(T) -> U</code></td>`	</td>	逆变</strong></td>	协变</td></tr>
`*const T</code></td>`	</td>	协变</td>	</td></tr>
`*mut T</code></td>`	</td>	不变</td>	</td></tr> </tbody></table> 让我们来逐条分析一下：</p> `&'a T</code> 对 'a</code> 和 T</code> 协变，这是因为 &</code> 是一个只读容器。</li>` &'a mut T</code> 对 'a</code> 协变，对 T</code> 不变。对 T</code> 不变很好理解，因为 &mut</code> 是可读写容器，就像前面例子里的 List<T></code> 一样。对 'a</code> 协变是因为，和类型系统的子类型不同，生命周期不存在读取和写入和区别，它只是指示了变量何时可用，当变量不可用时，即不能读取，也不能写入。所以可以将生命周期视为类型系统里的读取关系，所以它一直是协变的。</li> `Box<T></code> 和 Vec<T></code> 对 T</code> 协变，这放在其他语言里是不可能的，但是在 Rust 中，如果当前拥有着一个容器的所有权时，可以保证一定没有其他人能够读取和修改它。</li>` `UnsafeCell<T></code> 和 Cell<T></code> 是用来实现内部可变性的，因此它是可读写容器，对 T</code> 不变。</li>` `fn(T) -> U</code> 函数类型和前面的函数类型是一样的，特别的是，这里的对函数参数 T</code> 逆变是 Rust 中唯一的逆变。</li>` const T</code> / mut T</code> 和 &'a T</code> / &'a mut T</code> 类似，这里就不再赘述。</li> </ul> 最后，引用 The Rustonomicon</em> 中的例子，稍作修改：</p> fn</span> assign</span><</span>T</span>>(</span>input</span>: &</span>mut</span> T</span>,</span> val</span>:</span> T</span>) {</span></span> </span>input</span> =</span> val</span>;</span></span> }</span></span> </span> fn</span> main</span>() {</span></span> let mut</span> hello</span>: &'</span>static str</span> =</span> "hello"</span>;</span></span> {</span></span> let</span> world</span>: &</span>str</span> = &</span>String</span>::</span>from</span>(</span>"world"</span>);</span> // &'world str</span></span> assign</span>(&</span>mut</span> hello</span>,</span> world</span>);</span></span> }</span></span> println!</span>(</span>"{hello}"</span>);</span></span> }</span></span></code></pre> 很明显，这里是不安全的，无法通过编译，在最后的 println!()</code> 处 world</code> 已经被释放了。</p> 这里的问题在于，调用 assign</code> 时，我们传入的两个类型是 &mut &'static str</code> 和 &'world str</code>，根据 &'a T</code> 对 'a</code> 协变，所以 &'static str</code> 是 &'world str</code> 的子类型。但是 &'a mut T</code> 对 T</code> 不变，所以这里，编译器不能对它做任何子类型化，因此，按照函数声明中的要求，val</code> 参数的 T</code> 和 &mut T</code> 中的 T</code> 必须“完全相同”，而这里 val</code> 中的 T</code> 是 &'world str</code>，不是 &'static str</code>，所以生命周期检查失败了。</p> 如果修改成这样就可以通过检查了：</p> fn</span> assign</span><</span>T</span>>(</span>input</span>: &</span>mut</span> T</span>,</span> val</span>:</span> T</span>) {</span></span> </span>input</span> =</span> val</span>;</span></span> }</span></span> </span> fn</span> main</span>() {</span></span> let</span> hello</span>: &'</span>static str</span> =</span> "hello"</span>;</span></span> {</span></span> let mut</span> world</span>: &</span>str</span> = &</span>String</span>::</span>from</span>(</span>"world"</span>);</span> // &'world str</span></span> assign</span>(&</span>mut</span> world</span>,</span> hello</span>);</span></span> }</span></span> }</span></span></code></pre> 我们传入的两个类型是 &mut &'world str</code> 和 &'static str</code>，同样，要求 val</code> 中的 T</code> 和 &mut T</code> 中的 T</code> 完全相同，可是这里传入的也不相同啊？这涉及到了 Rust 的类型自动强转机制，“在函数传参时，实参将自动转换为形参”，允许转换的规则中有一条“子类型可以转换为父类型”，虽然 &mut</code> 无法进行子类型化，但 &'static str</code> 是 &'world str</code> 的子类型，&'static str</code> 被自动强转为 &'world str</code>，因此通过了生命周期检查。上面的例子，则无法进行上述的自动强转，所以生命周期检查失败了。</p> 参考</a></h2> Subtyping and Variance - The Rustonomicon</a> （中文翻译</a>）</li> Subtyping and Variance - The Rust Reference</a> （中文翻译</a>）</li> Type coercions - The Rust Reference</a> （中文翻译</a>）</li> 逆变、协变与子类型，以及 Rust</a></li> </ul> 编写现代的 Python st1020 — Tue, 24 Oct 2023 00:00:00 +0000 好久没写博客了，今天想结合我个人的经验聊一聊如何编写现代的 Python 代码。</p> 在聊这个问题之前，首先要定义一下什么是“现代的 Python”和我为什么想要使用这种方式编写 Python。</p> 或许你听说过“Modern C++”，这通常指的是 C++11 之后的 C++ 标准，现代的 C++ 带来了许多新的特性，如智能指针、auto、更强大的标准库、增强的 for 循环、移动语义、lambda 表达式等，这些新特性使得 C++ 赶上了时代的脚步，大大提高了开发的效率。</p> 而 Python 作为诞生于三十多年前的编程语言，在这三十年间也发生了许多变化，最著名的变化莫过于 Python 2 到 Python 3 的不兼容升级。但本文我想聊的并非所有的 Python 新特性，毕竟 Python 的新特性可以直接在 What’s New in Python</a> 中找到，我想说的是一种编程风格或者说编程范式。</p> 这些思想很大程度上并非我的原创，而是来自于 Rust 语言。自从我开始使用 Rust 语言，它就很大程度上影响了我编写其他语言的的方式，尤其是 Python 语言。</p> 这篇博客还受到了 Writing Python like it's Rust</a> 的启发，其中的很多思想都和我不谋而合 (实际上我是写到一半才发现这篇文章的，感觉他把我想说的都说的差不多了)。</p> 开始之前：Formatter and Linter</a></h2> 在开始之前，我想先聊一个和本文关系不大的问题，那就是格式化和风格检查。</p> 几乎所有的语言都有官方推荐或社区广泛认同的代码格式和风格，而许多诞生比较晚的现代语言还在工具链中附带了 Formatter 和 Linter，比如 Rust 的 rustfmt</code> 和 clippy</code>。但很遗憾 Python 并没有一个附带的 Formatter 和 Linter。</p> 在所有 Python 的 Formatter 中我一直使用的是 black</a>，因为它相对比较严格，就像前端届的 Prettier 一样，它是一个“固执己见”(opinionated) 的格式化工具。我觉得 Formatter 的主要作用就是提供一个尽可能统一的格式，以尽可能省去手动格式化和时间和团队协作中对格式的争论，因此，Formatter 越严格越好，至于细节的格式，我并没有特别的偏好，只要不太奇怪，严格和统一就是最好的。</p> 而在 Linter 中我首推 Ruff</a>，它是一个用 Rust 编写的 Python Linter，因此具有极快的速度。是真的非常快，比传统的 Python Linter 快几个数量级。除此之外，它的规则也比较全，涵盖了代码风格的方方面面，可以完全替代 Flake8 和 isort。除此之外，如果需要更加细致的代码检查的话可以选择 Pylint</a>，它会对代码进行更加深入的静态检查，但代价是很慢，比 Ruff 慢 2-3 个数量级。</p> 在现代语言中，我认为应该永远使用尽可能严格的 Formatter 和 Linter，人是一个不精确的机器，没有人能永远按照最佳实践编写代码，尽管关于软件架构和复杂的逻辑仍然需要人的设计，但至少我们应该在细节的代码格式和风格方面尽可能遵循最佳实践，计算机擅长干的事就不要让人来做，让工具来约束是最简单的。并且尽可能严格的 Formatter 和 Linter 也有助于团队协作时避免风格的差异。</p> 现代 Python 的哲学</a></h2> 我认为，在程序设计中的一个很重要的原则就是“承诺”，比如 Rust 的宣传的重点就是它的安全性承诺和零开销抽象承诺，即只要不使用 unsafe</code> 那就不可能出现内存安全问题，以及只需要为用到的功能付出时间、空间代价。</p> 很显然，Python 作为一个有 GC 的语言，已经提供了安全性承诺，而零开销抽象也并非 Python 语言所关注的重点，这里我希望的是通过一种良好的代码风格做到健壮性 (也被翻译为鲁棒性，但我觉得这个翻译很糟糕)。</p> 传统上，我们编写 Python 时很容易写出类似下面的代码：</p> def</span> get_person</span>(</span>person_id</span>):</span></span> ...</span></span> return</span> {</span></span> "id"</span>: person_id,</span></span> "name"</span>:</span> "Alice"</span>,</span></span> "permission"</span>: {</span></span> "id"</span>:</span> 0</span>,</span></span> "is_admin"</span>:</span> True</span>,</span></span> "user_groups"</span>: [],</span></span> },</span></span> }</span></span> </span> </span> def</span> check_permission</span>(</span>person</span>):</span></span> return</span> person[</span>"permission"</span>][</span>"is_admin"</span>]</span> or</span> "root"</span> in</span> person[</span>"permission"</span>][</span>"user_groups"</span>]</span></span> </span></code></pre> 这种代码是不好的，因为它很容易被误用，并且会提高修改、维护和使用的成本。当我们使用 check_permission</code> 这个函数时，在不阅读函数体的情况下，我们无法确定这里需要的 person 参数到底是什么，在编写或修改这个函数时，我们也无法保证正确性，比如出现 person 字典的结构发生变更但忘记修改 check_permission</code> 函数，或者 check_permission</code> 函数里的字段名出现 typo 等。</p> 就像墨菲定律一样，任何可能被误用的，最终一定会被误用。更重要的是，这样的代码没有提供任何健壮性承诺，当一个人 (也可能是自己) 在使用和修改这样的代码时，必须谨小慎微，并且永远无法保证自己没有出错。</p> 因此，我认为，更加现代的 Python 编写风格就是要利用 Python 在近几个版本提供的几个有用的新特性来尽可能避免“不确定性”，提供更多的健壮性承诺，为了做到这一点，我们需要合理地限制 Python 的动态特性、坚持尽可能早的异常 (编译期异常优于运行时异常) 和使非法状态不可表示。</p> 类型注解 (Type Hints)</a></h2> 首先，也是最重要的就是为 Python 代码编写类型注解，类型注解是在 PEP 484</a> 和 PEP 483</a> 中首次引入，并在 Python 3.5 版本正式开始支持的特性。直到现在仍在不断迭代和添加新特性中。</p> 类型注解可以为 Python 提供静态的类型检查，它仅在静态类型检查器中被使用，而没有运行时性能损耗，即 Python 的类型注解会在运行时被忽略 (实际上可以被运行时获取，会被存储在 __annotations__</code> 等魔术字段中，但不会进行检查)。</p> 这相当于为 Python 引入了而外的编译期检查，能够在运行前避免常见的类型问题。常见的静态类型检查工具有 Python 官方提供的 mypy</a>、微软提供的 pyright</a>、FaceBook 提供的 pyre</a> 和 Google 提供的 pytype</a>，他们在一些细节上有不同的处理方式。</p> 需要指出的是，我觉得 Python 的类型注解并不十分强大，与 Rust 这种静态类型语言自然没法比，与 TypeScript 相比也有不小的差距 (TS 的类型系统甚至是图灵完备的)，但是，这也并非是一个缺点，Python 的类型注解系统是十分 Pythonic 的，并且足够简单易用，不会像 TS 一样有非常复杂的类型体操，更重要的是，Python 的类型注解一直在进步，几乎每个版本都有关于类型注解的新特性加入。</p> 很多人觉得为 Python 编写类型注解会影响编码速度。但我认为并非如此，单纯考虑额外编写类型注解的时间当然至少增加了打字的时间。但首先，在大多数情况下，即使不编写类型注解，在编写代码时自己也是清楚变量的类型的，因为类型本身就是程序的一部分，因此，显式写出类型只增加了打字时间而没有增加思考时间，大部分编程的速度瓶颈都不在打字时间上。其次，编写类型注解可以充分利用编辑器的自动提示功能，在很多情况下反而可以加快编码速度。最后，大多数程序都不是只编写一次、只运行一次、长度很短的小脚本，算上修改维护的时间为 Python 编写类型注解绝对是合算的。</p> 使用数据类 (dataclass)</a></h2> 数据类是在 Python 3.7 引入的，它基本上相当于 Python 中的结构体，不同于字典这种松散的结构，就像结构体一样，数据类可以限定字段的多少、名称、类型。</p> 开始的例子使用数据类重写后：</p> from</span> dataclasses</span> import</span> dataclass</span></span> </span> </span> @dataclass</span></span> class</span> Permission</span>:</span></span> id</span>:</span> int</span></span> is_admin:</span> bool</span></span> user_groups: list[</span>str</span>]</span></span> </span> </span> @dataclass</span></span> class</span> Person</span>:</span></span> id</span>:</span> int</span></span> name:</span> str</span></span> permission: Permission</span></span> </span> </span> def</span> get_person</span>(</span>person_id</span>:</span> int</span>) -> Person:</span></span> ...</span></span> return</span> Person(</span></span> id</span>=person_id,</span></span> name</span>=</span>"Alice"</span>,</span></span> permission</span>=Permission(</span></span> id</span>=</span>0</span>,</span></span> is_admin</span>=</span>True</span>,</span></span> user_groups</span>=[],</span></span> ),</span></span> )</span></span> </span> </span> def</span> check_permission</span>(</span>person</span>: Person) -></span> bool</span>:</span></span> return</span> person.permission.is_admin</span> or</span> "root"</span> in</span> person.permission.user_groups</span></span> </span></code></pre> 使用数据类而非字典的优势是显而易见的，首先，它提供了嵌套类型中的类型提示和检查，避免了类型和字段错误，其次，它非常方便重构，修改字段名称后大部分编辑器都可以自动进行重构。</p> Python 自带的 dataclasses</code> 并不会进行运行时类型检查，因此不适用于序列化和反序列化场景中，如果需要运行时数据校验的话可以使用 Pydantic</a>。</p> NewType</a></h2> 在 Rust 中存在一种被称为 NewType</code> 的用法，可以查看下面的 Rust 官方的例子</a>：</p> struct</span> Years</span>(</span>i64</span>);</span></span> </span> struct</span> Days</span>(</span>i64</span>);</span></span> </span> impl</span> Years</span> {</span></span> pub fn</span> to_days</span>(&</span>self</span>) -></span> Days</span> {</span></span> Days</span>(</span>self</span>.</span>0</span> </span> 365</span>)</span></span> }</span></span> }</span></span> </span> </span> impl</span> Days</span> {</span></span> /// truncates partial years</span></span> pub fn</span> to_years</span>(&</span>self</span>) -></span> Years</span> {</span></span> Years</span>(</span>self</span>.</span>0</span> /</span> 365</span>)</span></span> }</span></span> }</span></span> </span> fn</span> old_enough</span>(</span>age</span>: &</span>Years</span>) -></span> bool</span> {</span></span> age</span>.</span>0</span> >=</span> 18</span></span> }</span></span> </span> fn</span> main</span>() {</span></span> let</span> age</span> =</span> Years</span>(</span>5</span>);</span></span> let</span> age_days</span> =</span> age</span>.</span>to_days</span>();</span></span> println!</span>(</span>"Old enough {}"</span>,</span> old_enough</span>(&</span>age</span>));</span></span> println!</span>(</span>"Old enough {}"</span>,</span> old_enough</span>(&</span>age_days</span>.</span>to_years</span>()));</span></span> // println!("Old enough {}", old_enough(&age_days));</span></span> }</span></span> </span></code></pre> 它可以指定一个和原有的类型完全一致的新类型，但额外指定它的预期用途，比如上面的例子，i64</code> 只表示这是一个 64 位整数而没有任何其他的信息，而 Years</code> 则进一步说明了这是一个用于表示年份的整数。同时 NewType 也限制了新类型的用法，即封装后的类型只有 to_days()</code> 这一个关联方法，而无法再使用对 i64</code> 可以使用的其他方法，因为其他方法对于“年”这个类型来说很可能是没有意义的。</p> 这也是一个防止误用的技巧。如果上面的 old_enough</code> 函数的签名是：fn old_enough(age: &i64) -> bool</code>，那么使用者就无法从函数的读出 age</code> 的单位是秒、天、月还是年，从而可能造成误用。使用 NewType 可以让类型包含更多的信息，进一步明确类型。</p> 在获得上述好处的同时，完全没有任何性能代价，NewType 被编译后完全就是原本的类型，所有的限制都是编译期的，没有任何运行时损耗。</p> Python 中也提供了 NewType 的支持。</p> from</span> typing</span> import</span> NewType</span></span> </span> Years = NewType(</span>"Years"</span>,</span> int</span>)</span></span> Days = NewType(</span>"Days"</span>,</span> int</span>)</span></span> </span> </span> def</span> old_enough</span>(</span>age</span>: Years) -></span> bool</span>:</span></span> return</span> age >=</span> 18</span></span> </span> </span> if</span> __name__</span> ==</span> "__main__"</span>:</span></span> age = Years(</span>5</span>)</span></span> print</span>(</span>f</span>"Old enough </span>{</span>old_enough(age)</span>}</span>"</span>)</span></span> </span></code></pre> Python 是支持继承的，因此上面的操作和创建一个 Years</code> 类继承 int</code> 的效果类似，但是，创建子类是有运行时开销的，而 NewType 则没有。NewType 仅在类型检查中被使用，相当于在类型检查中认为是一个子类，在运行时认为是它本身。</p> 组合优于继承</a></h2> 在 Rust 中是没有类 (class) 的，但存在 trait</a> 的概念，类似其他语言的接口 (protocols/interfaces</a>)。</p> 因为 Python 支持多继承和抽象基类，因此在 Python 中组合和继承的差别实际上是比较模糊的。</p> 在 Python 中可以利用抽象基类实现组合：</p> from</span> abc</span> import</span> ABC, abstractmethod</span></span> </span> </span> class</span> Openable</span>(ABC):</span></span> @abstractmethod</span></span> def</span> open</span>(</span>self</span>):</span></span> ...</span></span> </span> </span> class</span> Closable</span>(ABC):</span></span> @abstractmethod</span></span> def</span> close</span>(</span>self</span>):</span></span> ...</span></span> </span> </span> class</span> File</span>(</span>Openable</span>,</span> Closable</span>):</span></span> def</span> open</span>(</span>self</span>):</span></span> print</span>(</span>"open"</span>)</span></span> </span> def</span> close</span>(</span>self</span>):</span></span> print</span>(</span>"close"</span>)</span></span> </span> </span> def</span> open_it</span>(</span>openable</span>: Openable):</span></span> openable.open()</span></span> </span> </span> open_it(File())</span></span> </span></code></pre> 或者利用 PEP 544</a> 在 Python 3.8 中引入的 Protocol 和结构子类型：</p> from</span> typing</span> import</span> Protocol</span></span> </span> </span> class</span> Openable</span>(</span>Protocol</span>):</span></span> def</span> open</span>(</span>self</span>):</span></span> ...</span></span> </span> </span> class</span> Closable</span>(</span>Protocol</span>):</span></span> def</span> close</span>(</span>self</span>):</span></span> ...</span></span> </span> </span> class</span> File</span>:</span></span> def</span> open</span>(</span>self</span>):</span></span> print</span>(</span>"open"</span>)</span></span> </span> def</span> close</span>(</span>self</span>):</span></span> print</span>(</span>"close"</span>)</span></span> </span> </span> def</span> open_it</span>(</span>openable</span>: Openable):</span></span> openable.open()</span></span> </span> </span> open_it(File())</span></span> </span></code></pre> 它们的主要区别在于前者需要显示声明而后者不需要，前者提供了运行时检查 (有运行时开销) 而后者没有。通常认为后者是更加 pythonic 的。</p> 构造函数</a></h2> 在 Rust 中不存在类似 Python 中 __init__</code> 的默认构造器，取而代之的是使用普通的关联函数进行构造，这有什么好处呢？</p> 这有助于更加明确地实现一个类型有多个构造器的情况，比如：</p> #[derive(</span>Debug</span>)]</span></span> struct</span> Rectangle</span> {</span></span> width</span>:</span> u32</span>,</span></span> height</span>:</span> u32</span>,</span></span> }</span></span> </span> impl</span> Rectangle</span> {</span></span> fn</span> new</span>(</span>width</span>:</span> u32</span>,</span> height</span>:</span> u32</span>) -></span> Self</span> {</span></span> Self</span> {</span> width</span>,</span> height</span> }</span></span> }</span></span> </span> fn</span> square</span>(</span>size</span>:</span> u32</span>) -></span> Self</span> {</span></span> Self</span> {</span></span> width</span>:</span> size</span>,</span></span> height</span>:</span> size</span>,</span></span> }</span></span> }</span></span> }</span></span> </span> fn</span> main</span>() {</span></span> Rectangle</span>::</span>new</span>(</span>1</span>,</span> 2</span>)</span></span> Rectangle</span>::</span>square</span>(</span>1</span>)</span></span> }</span></span> </span></code></pre> 对于 Python 传统上则可能会写成：</p> from</span> typing</span> import</span> overload</span></span> </span> </span> class</span> Rectangle</span>:</span></span> width:</span> int</span></span> height:</span> int</span></span> </span> @overload</span></span> def</span> __init__</span>(</span>self</span>,</span> width</span>:</span> int</span>) -></span> None</span>:</span></span> ...</span></span> </span> @overload</span></span> def</span> __init__</span>(</span>self</span>,</span> width</span>:</span> int</span>,</span> height</span>:</span> int</span>) -></span> None</span>:</span></span> ...</span></span> </span> def</span> __init__</span>(</span>self</span>,</span> width</span>:</span> int</span>,</span> height</span>:</span> int</span> \|</span> None</span> =</span> None</span>) -></span> None</span>:</span></span> if</span> height</span> is None</span>:</span></span> height = width</span></span> self</span>.width = width</span></span> self</span>.height = height</span></span> </span> </span> if</span> __name__</span> ==</span> "__main__"</span>:</span></span> Rectangle(</span>1</span>,</span> 2</span>)</span></span> Rectangle(</span>1</span>)</span></span> </span></code></pre> 为什么一个结构体/类只能有一个构造函数呢？即使使用了 overload</code> 类型注解，上面的 Python 代码仍然并不利于识读，当一个不熟悉 Rectangle</code> 的人看到类似 Rectangle(1)</code> 的代码，他并无法直接认识到这是用于构造正方形的方法。</p> 因此我认为可以使用下面的方式实现：</p> from</span> dataclasses</span> import</span> dataclass</span></span> from</span> typing</span> import</span> Self</span></span> </span> </span> @dataclass</span></span> class</span> Rectangle</span>:</span></span> width:</span> int</span></span> height:</span> int</span></span> </span> @</span>classmethod</span></span> def</span> square</span>(</span>cls</span>,</span> size</span>:</span> int</span>) -> Self:</span></span> return</span> cls</span>(size, size)</span></span> </span> </span> if</span> __name__</span> ==</span> "__main__"</span>:</span></span> Rectangle(</span>1</span>,</span> 2</span>)</span></span> Rectangle.square(</span>1</span>)</span></span> </span></code></pre>代数数据类型和模式匹配</a></h2> 代数数据类型 (algebraic data type(ADT)</a>) 指的是一种复合类型，包括积类型与和类型。</p> 积类型的典型例子就是元组，其可能值是其字段类型可能值的笛卡尔积。</p> 和类型的例子是 Rust 中的 enum</code> 和 Python 中的 Union</code>，其可能值是其字段类型的并集。</p> class</span> A</span>: ...</span></span> class</span> B</span>: ...</span></span> class</span> C</span>: ...</span></span> class</span> D</span>: ...</span></span> </span> Type1 = A \| B</span></span> Type2 = C \| D</span></span> </span> product_type = tuple[Type1, Type2]</span></span> # possible values: (A, C) \| (A, D) \| (B, C) \| (B, D)</span></span> sum_type = Type1 \| Type2</span></span> # possible values: A \| B \| C \| D</span></span> </span></code></pre> ADT 中积类型的应用比较简单，在大多数语言中均有广泛应用，下面重点关注一下和类型。</p> 和类型和继承/接口不同在于，继承/接口是开放的，而和类型是封闭的，也就是说，如果我们指定一个函数可以接受 A 类型，那么它就可以接受 A 的所有子类型，但我们无从得知这个 A 有几个子类型，因此只能使用定义在 A 中的公共方法。而如果是和类型，则可以显式地得知这个它是由几个字段类型组合而成的，从而对每个字段类型分别进行处理。</p> 结合模式匹配，就可以实现类似下面的例子，可以静态检查是否忘记了处理某种情况。</p> enum</span> Node</span> {</span></span> If</span> {</span></span> test</span>:</span> Box</span><</span>Node</span>>,</span></span> consequent</span>:</span> Box</span><</span>Node</span>>,</span></span> alternate</span>:</span> Option</span><</span>Box</span><</span>Node</span>>>,</span></span> },</span></span> While</span> {</span></span> test</span>:</span> Box</span><</span>Node</span>>,</span></span> body</span>:</span> Box</span><</span>Node</span>>,</span></span> },</span></span> Add</span> {</span></span> left</span>:</span> Box</span><</span>Node</span>>,</span></span> right</span>:</span> Box</span><</span>Node</span>>,</span></span> },</span></span> Ident</span>(</span>String</span>),</span></span> }</span></span> </span> fn</span> eval</span>(</span>node</span>: &</span>Node</span>) {</span></span> match</span> node</span> {</span></span> Node</span>::</span>If</span> {</span></span> test</span>,</span></span> consequent</span>,</span></span> alternate</span>,</span></span> } =></span> todo!</span>(),</span></span> Node</span>::</span>While</span> {</span> test</span>,</span> body</span> } =></span> todo!</span>(),</span></span> Node</span>::</span>Add</span> {</span> left</span>,</span> right</span> } =></span> todo!</span>(),</span></span> Node</span>::</span>Ident</span>(</span>ident</span>) =></span> todo!</span>(),</span></span> }</span></span> }</span></span> </span></code></pre> 对于 Python 来说，Python 在 3.10 引入了模式匹配 match-case</code> 语法：</p> from</span> __future__</span> import</span> annotations</span></span> </span> from</span> dataclasses</span> import</span> dataclass</span></span> from</span> typing</span> import</span> NewType, assert_never</span></span> </span> </span> @dataclass</span></span> class</span> If</span>:</span></span> test: Node</span></span> consequent: Node</span></span> alternate: Node \|</span> None</span></span> </span> </span> @dataclass</span></span> class</span> While</span>:</span></span> test: Node</span></span> body: Node</span></span> </span> </span> @dataclass</span></span> class</span> Add</span>:</span></span> left: Node</span></span> right: Node</span></span> </span> </span> Ident = NewType(</span>"Ident"</span>,</span> str</span>)</span></span> </span> Node = If \| While \| Add \| Ident</span></span> </span> </span> def</span> eval</span>(</span>node</span>: Node):</span></span> match</span> node:</span></span> case</span> If(test, consequent, alternate):</span></span> pass</span></span> case</span> While(test, body):</span></span> pass</span></span> case</span> Add(left, right):</span></span> pass</span></span> case</span> Ident(ident):</span></span> pass</span></span> case</span> _:</span></span> assert_never(node)</span></span></code></pre> 但是，Python 的类型系统并不强制要求匹配完所有可能的分支，因此，需要在最后添加 assert_never</code> 以要求类型检查器在未匹配完成时报错。</p> 总结</a></h2> 总之，编写所谓“现代的 Python”的关键就在于利用 Python 的类型系统来保证 Python 的健壮性。很多时候，在业务代码中，我们其实并不需要，也不应该需要 Python 提供的如此大的灵活性。</p> Absolute freedom mocks at justice. Absolute justice denies freedom. To be fruitful, the two ideas must find their limits in each other.</p> Albert Camus, The Rebel (1951)，as translated by Anthony Bower</p> </blockquote> Powered by Zola st1020 — Mon, 23 Oct 2023 00:00:00 +0000 在三年前这个博客从 Hexo 迁移到 Hugo 之后，这一次又从 Hugo 迁移到了 Zola。</p> 我之前使用的 Hugo 主题 LoveIt</a> 已经停止维护好久了 (所以爱是会消失的对吗)，本来我想 fork 一份自己维护一下的，取名为 LikeIt</a>，意为比“Love”少一点，主要就是删除了一些我用不到组件，然后修了一些 Bug(虽然好像引入了一些新的 Bug)。</p> 但在维护的过程中，我是在受不了。Go template 的阴间语法搭配上 Hugo 丰富而复杂的各种特性，再加上 LoveIt 主题本身的复杂性和我本身对 CSS 也不是很熟练，让维护工作十分不顺利。</p> 尤其要点名批评 Go template 这个混沌邪恶的产物，它的语法实在是非常的反直觉了，感觉就像函数式语言和命令式语言的缝合。</p> 除此之外，对于 Hugo 我也有一些抱怨，随着不断的发展，它已经太重了，这使得它的学习成本比较高，具体可以看一下 Migrating my blog to Zola</a> 这篇博客中他迁移的原因。</p> 所以，我觉得是时候换一个新的 SSG 了，对于新的 SSG 我有如下要求：</p> 拥有一个不那么阴间的模版语法。</li> 使用非脚本语言编写。往往脚本语言编写的 SSG 的速度都不是很理想，并且我也不是很喜欢生成博客时还需要装一个 Node 环境或者 Python 的虚拟环境，这也是多余的开销，我希望新的 SSG 最好零依赖，只有一个二进制文件。</li> 干净简单，约定优于配置，大多数功能都是可选的。</li> 满足上述条件的前提下，有尽可能多的使用人数和持续良好的维护。</li> </ol> 综合上述条件，我最终找到了 Zola</a>。它是用 Rust 语言编写的，因此可以做到零依赖，并且性能比宣称“The world’s fastest framework for building websites”的 Hugo 还要好。它的模版引擎使用的是同一个作者开发 Tera，这是一个语法高度类似 Jinja 的模块引擎，也是 Rust 生态中最热门的模版引擎之一。更重要的它很简单清晰，Page、Section 的结构非常简单易懂。</p> 但是，由于用户基数还不是很大，我并没有找到心仪的主题，也是防止新的主题再次停止维护，Zola 本身编写一个主题也十分简单，这次，我选择直接编写一个主题。</p> 可我对自己的 UI 设计能力并没有自信，所以最终还是选择移植一个 Hugo 主题，并在它的基础上修改。</p> 最终，我选择了 hugo-paper</a>，它是 Hugo 最热门的主题 hugo-PaperMod</a> 的前身，足够简洁美观，代码量也非常少，并且使用了 TailwindCSS。</p> 我把 hugo-paper 移植到了 Zola 之后还做了不少的修改，比如增加了目录、项目页面、存档页面、分类页面、Mermaid 支持、Admonition shortcode 等，还做了不少样式的调整，多亏了 TailwindCSS 和 Zola，修改起来非常容易。</p> 我将新的主题命名为 Kita</a>，这个玩了一个三语梗，Zola 在中文中读起来就像“走啦”，而 Kita 是日语“来た”(来了) 的罗马音，同时也致敬了孤独摇滚里的“归去来兮女士”喜多郁代 (Kita Ikuyo) 的名字。</p> 这次应该是最后一次迁移了 (如果 Zola 本身不停止维护的话，虽然即使停止维护功能也足够稳定和完整了)，有了自己的主题也方便之后随时修改啦。</p> 修复 MacOS 升级后 VSCode LLDB 调试错误 st1020 — Wed, 18 Oct 2023 00:00:00 +0000 最近升级了 MacOS 14 之后，发现无法使用 VSCode 调试 Rust 程序了，点击调试后程序直接闪退。调试控制台输出 Process exited with code -1.</code>。</p> 初步判断是 CodeLLDB</a> 拓展的问题，并在它的 GitHub 仓库里找到了解决方案。</p> https://github.com/vadimcn/codelldb/discussions/456</a></p> https://github.com/vadimcn/codelldb/issues/999</a></p> 看起来是一个老问题了，从 MacOS 12 开始就一直存在，修复的方法也很简单，只需要删除拓展目录下的 vadimcn.vscode-lldb-1.x.x/lldb/bindebugserver</code> 即可，删除 bindebugserver</code> 后拓展会自动使用系统提供的 bindebugserver</code>。</p> 根据作者的说法，CodeLLDB 捆绑的 debugserver 来自 XCode 10，但最新的 XCode 已经更新到 15 了，应该是新版本 MacOS 和老版本 debugserver 存在兼容性问题。</p> Git 重写历史和修复提交日期 st1020 — Sun, 15 Aug 2021 00:00:00 +0000 前几天，我发现之前项目中的一个历史提交的 commit 消息写错了，想要进行修改，记录一下修改的过程。</p> 修改最后一次提交</a></h2> 修改最后一次提交很简单，git 已经提供了一个命令进行更改：</p> git</span> commit</span> --amend</span></span></code></pre> 上述命令会打开一个编辑器，可以在编辑器中编辑要修改的 commit 消息，然后退出即可保存。</p> 可惜的是，我并不是这种情况，而是许多个提交之前的历史提交。</p> 修改历史提交</a></h2> 假设我们当前的提交记录是这样的：</p> commit c9837cd063d3591d86505d3ab095744173b863b2 (HEAD -> master)</span></span> Author: st1020 <stone_1020@qq.com></span></span> Date: Sun Aug 15 21:51:39 2021 +0800</span></span> </span> test commit 2</span></span> </span> commit 98a8bb09d823c5800f1b9ffbe8e2cb40fc8a456c</span></span> Author: st1020 <stone_1020@qq.com></span></span> Date: Sun Aug 15 21:51:10 2021 +0800</span></span> </span> test commit 1</span></span> </span> commit de14f7451ede9600a3172ef99f652d231791b16f</span></span> Author: st1020 <stone_1020@qq.com></span></span> Date: Sun Aug 15 21:50:34 2021 +0800</span></span> </span> Init Commit</span></span></code></pre> 需要将 test commit 1</code> 这条提交消息更改为 first commit</code>。</p> 首先，需要找到要修改的提交的前一个提交，即 de14f74</code>，执行变基：</p> git</span> rebase</span> -i</span> de14f74</span></span></code></pre> 执行上述命令会进入文本编辑器，应该会得到类似下面的信息：</p> pick 98a8bb0 test commit 1</span></span> pick c9837cd test commit 2</span></span> </span> # 变基 de14f74..c9837cd 到 de14f74（2 个提交）</span></span> #</span></span> # 命令：</span></span> # p, pick <提交> = 使用提交</span></span> # r, reword <提交> = 使用提交，但编辑提交说明</span></span> # e, edit <提交> = 使用提交，但停止以便在 sh 中修补提交</span></span> # s, squash <提交> = 使用提交，但挤压到前一个提交</span></span> # f, fixup [-C \| -c] <提交> = 类似于 "squash"，但只保留前一个提交</span></span> # 的提交说明，除非使用了 -C 参数，此情况下则只</span></span> # 保留本提交说明。使用 -c 和 -C 类似，但会打开</span></span> # 编辑器修改提交说明</span></span> # x, exec <命令> = 使用 sh 运行命令（此行剩余部分）</span></span> # b, break = 在此处停止（使用 'git rebase --continue' 继续变基）</span></span> # d, drop <提交> = 删除提交</span></span> # l, label <label> = 为当前 HEAD 打上标记</span></span> # t, reset <label> = 重置 HEAD 到该标记</span></span> # m, merge [-C <commit> \| -c <commit>] <label> [# <oneline>]</span></span> # . 创建一个合并提交，并使用原始的合并提交说明（如果没有指定</span></span> # . 原始提交，使用注释部分的 oneline 作为提交说明）。使用</span></span> # . -c <提交> 可以编辑提交说明。</span></span> #</span></span> # 可以对这些行重新排序，将从上至下执行。</span></span> #</span></span> # 如果您在这里删除一行，对应的提交将会丢失。</span></span> #</span></span> # 然而，如果您删除全部内容，变基操作将会终止。</span></span></code></pre> 我们现在需要把要修改的那次提交前的 pick</code> 更改为 edit</code> 或者 e</code>，之后 :wq</code> 保存退出：</p> edit 98a8bb0 test commit 1</span></span> pick c9837cd test commit 2</span></span></code></pre> 会输出以下信息：</p> 停止在 98a8bb0... test commit 1</span></span> 您现在可以修补这个提交，使用</span></span> </span> git commit --amend</span></span> </span> 当您对变更感到满意，执行</span></span> </span> git rebase --continue</span></span></code></pre> 修改完成后，执行 git commit --amend</code> 进入编辑器编辑提交消息，或者直接使用 git commit --amend -m "first commit"</code> 提交。</p> 之后，只需执行 git rebase --continue</code> 即可完成修改。</p> 再次查看 git log</code>：</p> commit 6118ceb757f15b602eff73db5adccb293a2d6821 (HEAD -> master)</span></span> Author: st1020 <stone_1020@qq.com></span></span> Date: Sun Aug 15 21:51:39 2021 +0800</span></span> </span> test commit 2</span></span> </span> commit 3bf6a7f2d1d493e5d7c831f2bb2922796e8ca380</span></span> Author: st1020 <stone_1020@qq.com></span></span> Date: Sun Aug 15 21:51:10 2021 +0800</span></span> </span> first commit</span></span> </span> commit de14f7451ede9600a3172ef99f652d231791b16f</span></span> Author: st1020 <stone_1020@qq.com></span></span> Date: Sun Aug 15 21:50:34 2021 +0800</span></span> </span> Init Commit</span></span></code></pre> 会发现提交消息已经被修改了，并且因为变基，这次修改的提交及其之后的提交的 SHA-1 全都发生了改变。</p> 如果已经将这些提交推送到了远程仓库，那么可以执行 git push -f</code> 强制推送。</p> 修复提交日期</a></h2> 但是，当我强制推送到了 github 远程仓库后却发现，github 提交记录中被修改的提交后的提交的日期是全都变成了今天，但是 git log</code> 中的明明没有问题啊？</p> 经过一番查找，我最终发现，git 的 commit 的日期实际上包含了两个日期，分别是 AuthorDate</code> 和 CommitDate</code>，git log</code> 中默认显示的是 AuthorDate</code> 而 github 的提交记录中显示的则是 CommitDate</code>，上述的变基操作不会改变 AuthorDate</code> 但却改变了 CommitDate</code>。</p> 我们可以通过 git log --pretty=fuller</code> 命令查看：</p> commit 6118ceb757f15b602eff73db5adccb293a2d6821 (HEAD -> master)</span></span> Author: st1020 <stone_1020@qq.com></span></span> AuthorDate: Sun Aug 15 21:51:39 2021 +0800</span></span> Commit: st1020 <stone_1020@qq.com></span></span> CommitDate: Sun Aug 15 22:09:37 2021 +0800</span></span> </span> test commit 2</span></span> </span> commit 3bf6a7f2d1d493e5d7c831f2bb2922796e8ca380</span></span> Author: st1020 <stone_1020@qq.com></span></span> AuthorDate: Sun Aug 15 21:51:10 2021 +0800</span></span> Commit: st1020 <stone_1020@qq.com></span></span> CommitDate: Sun Aug 15 22:07:22 2021 +0800</span></span> </span> first commit</span></span> </span> commit de14f7451ede9600a3172ef99f652d231791b16f</span></span> Author: st1020 <stone_1020@qq.com></span></span> AuthorDate: Sun Aug 15 21:50:34 2021 +0800</span></span> Commit: st1020 <stone_1020@qq.com></span></span> CommitDate: Sun Aug 15 21:50:34 2021 +0800</span></span> </span> Init Commit</span></span></code></pre> 或者通过 git log --format=format:"%h %ai %ci"</code> 方便地比较 AuthorDate</code> 和 CommitDate</code>。</p> 6118ceb 2021-08-15 21:51:39 +0800 2021-08-15 22:09:37 +0800</span></span> 3bf6a7f 2021-08-15 21:51:10 +0800 2021-08-15 22:07:22 +0800</span></span> de14f74 2021-08-15 21:50:34 +0800 2021-08-15 21:50:34 +0800</span></span></code></pre> 第一种方法</strong>是，我们可以在前面的提交步骤中，将命令修改为：</p> GIT_COMMITTER_DATE</span>=</span>"2021-08-15 21:51:10 +0800"</span> git</span> commit</span> --amend -m</span> "first commit"</span></span></code></pre> 这里的 GIT_COMMITTER_DATE</code> 要设置成这次提交的 AuthorDate</code>。</p> 但是即使这样做，这次提交之后的提交的日期也会变化，得到的 git log --format=format:"%h %ai %ci"</code> 会类似这样：</p> ff6edfd 2021-08-15 21:51:39 +0800 2021-08-15 22:31:06 +0800</span></span> 699345c 2021-08-15 21:51:10 +0800 2021-08-15 21:51:10 +0800</span></span> de14f74 2021-08-15 21:50:34 +0800 2021-08-15 21:50:34 +0800</span></span></code></pre> 我们需要类似之前修改提交消息的方法，通过变基再去修改它的后一条消息的提交时间，提交时的命令使用：</p> GIT_COMMITTER_DATE</span>=</span>"2021-08-15 21:51:39 +0800"</span> git</span> commit</span> --amend --no-edit</span></span></code></pre> 但如果要修改的消息的提交后有很多的提交，就需要反复执行上面的操作，非常麻烦，所以显然不是什么好办法。</p> 第二种方法</strong>就简单了很多，我们可以直接执行下面的命令即可将所有的提交的 CommitDate</code> 修改为 AuthorDate</code>。虽然 filter-branch</code> 指令因为有很多的坑已经不推荐使用了，但像我们这种简单的操作还是没问题的。</p> git</span> filter-branch</span> --env-filter</span> 'export GIT_COMMITTER_DATE="$GIT_AUTHOR_DATE"'</span></span></code></pre>参考资料</a></h2> Git - 重写历史</a></li> Force GIT_COMMITTER_DATE = GIT_AUTHOR_DATE</a></li> Git - git-filter-branch Documentation</a></li> Git - pretty-formats Documentation</a></li> Git - git-commit Documentation - COMMIT INFORMATION</a></li> </ul> Python 异步 IO 实用教程 st1020 — Tue, 10 Aug 2021 00:00:00 +0000 网络上大部分关于 Python 异步 IO 的教程受制于历史原因，往往都是从基于生成器的协程开始讲起的，但是，基于生成器的协程在 Python 3.8 版本中已经被弃用并且将在 Python 3.10 版本中被移除，从 Python 3.7 版本开始，异步 IO 库也发生了许多更改，添加了许多便于使用的高层级 API，但许多教程仍只涉及低层级 API，使初学者非常迷惑，觉得异步 IO 是一个很难使用的东西。为了尝试解决这些问题，我写了这篇教程，本篇仅涉及 Python 异步 IO 的基本概念和常用的非常简单的使用方法。</p> 异步 IO 与并发执行</a></h2> 首先我们要明白的异步 IO 的本质是什么。</p> 如果我们希望一个代码能够并发执行，有这几种方式，多进程，多线程和协程，它们在 Python 中分别对应了 multiprocessing</a>，threading</a> 和 asyncio</a> 库，在历史上，进程曾是大部分分时系统中程序运行的基本单位，而在现代操作系统中，进程是线程的容器。通俗的来讲，系统中运行的每一个程序都是一个进程，而每个进程有包含多个线程。每个线程都可以并行运行。</p> graph TD; 操作系统-->进程1; 操作系统-->进程2; 进程1-->线程1-1; 进程1-->线程1-2; 进程2-->线程2-1; </pre> 但是，实际上它们真的在并行运行吗？答案是不确定的，这取决于 CPU 的核心数，在“远古”时代，CPU 只有一个核心，所以在物理层面上，进程与线程并没有办法并行执行，于是操作系统用一个方法“骗过”了用户，通过快速地切换运行的进程来产生一种它们正在并行运行的错觉，所以如果你的电脑只有一个核心，并且你的程序只涉及单纯的 CPU 计算，那么多线程或多进程并不会提高运行的效率，反而可能会因为调度过程中的损耗而浪费部分 CPU 资源。但好在现在的 CPU 都有多个核心了，每个线程可以在独立的 CPU 上运行，所以多线程技术可以显著加快计算的速度。不过 Python 语言的最常用实现 CPython 由于 GIL 的存在，并不能很好的利用多线程，所以对于 CPU 密集型的程序需要使用多进程代替多线程。</p> 实际上，计算机的 CPU 的运算速度远远大于网络或磁盘等 IO(输入/输出)。在很多情境下，我们的程序都不是 CPU 密集型，而是 IO 密集型的，也就是频繁地访问网络或磁盘，而对于 CPU 计算消耗的时间不是很敏感。</p> 传统的同步 IO，在 IO 操作过程中当前线程会被挂起，线程会等待 IO 操作完成在继续完成下面的代码。举一个例子，我们的程序要下载 100 个文件，如果我们使用同步 IO，程序向服务器发送一个网络请求，等 1 秒才能获得返回的信息，程序会等待返回信息后再继续进行下一个请求，100 个文件就需要至少 100 秒。所以我们必须使用多线程或多进程来并行下载，100 个线程同时发出网络请求，然后一起等 1 秒，一共只需要消耗 1 秒。</p> 但是这里使用多线程或者多进程也许有些浪费，毕竟多线程会造成额外的系统资源开销，进程和线程数量也不能无限多下去，并且稍有不慎还会造成各种奇怪的 bug。或许我们可以试图从源头解决问题，那就是为什么 IO 操作一定要阻塞线程呢？可以想象这样的一种情况，程序发送一个网络请求，但不等待它返回结果就继续发送第二个网络请求，以此类推，发送请求是 CPU 操作，100 个请求可能只需要 1 毫秒就能完成，然后等待它们返回后再进行处理，同样，一共也只需要 1s 就能完成！这就是异步 IO，为了更好地发挥异步 IO 的威力，Python 引入了协程的概念。</p> 协程</a></h2> 协程 (Coroutines) 又叫纤程 (Fiber)。我们暂且将协程理解为一种特殊的子程序 (函数)。</p> tip </div> Tip</strong></span> </div> 实际上，上面的那句话是错误的，正确的是：子程序是协程的一种特例。</p> 不过大多数语言都有子程序的概念，但不一定有协程的概念，在 Python 中函数也并不是协程的子类。</p> </div> </div> 在 Python 中协程用 async/await</code> 语法进行声明：</p> import</span> asyncio</span></span> </span> async def</span> main</span>():</span></span> await</span> foo()</span></span> print</span>(</span>'end'</span>)</span></span> </span> async def</span> foo</span>():</span></span> print</span>(</span>'hello'</span>)</span></span> await</span> asyncio.sleep(</span>1</span>)</span></span> </span> asyncio.run(main())</span></span></code></pre> 协程在声明时需要使用 async def</code> 代替 def</code>，而在调用时需要使用 await</code> 来代替直接调用。不使用 await</code> 直接调用一个协程并不会使它运行，只会得到一个协程对象。</p> 在最外层则需要通过 asyncio.run()</code> 来运行一个协程。</p> 上面的程序的运行结果应该类似于：</p> import</span> time</span></span> </span> def</span> main</span>():</span></span> foo()</span></span> print</span>(</span>'end'</span>)</span></span> </span> def</span> foo</span>():</span></span> print</span>(</span>'hello'</span>)</span></span> time.sleep(</span>1</span>)</span></span> </span> main()</span></span></code></pre> 那么我们多写了那么多代码到底有什么用呢？虽然它们运行的效果是相同的，但是原理却并不相同，前者在调用 await asyncio.sleep(1)</code> 时它实际上是挂起了当前的任务</strong>，以允许其他任务的运行，当然这里并没有其他的任务。后者的 time.sleep(1)</code> 则是挂起 (阻塞) 了当前的线程</strong>。</p> 可等待对象</a></h2> 上面我们提到了 await</code> 语句用于运行协程，实际上它表示的是等待协程运行完毕，就像同步程序一样，所以上面的两个程序效果是相同。</p> 在 Python 中所有可以被 await</code> 语句等待的对象都叫做可等待对象，协程就是一种可等待对象。可等待对象有三种主要类型：协程 (coroutine)，任务 (Task) 和 Future。</p> 其中 Future 是一种低层级的可等待对象，我们暂且不讨论，下面我们来了解一下任务。</p> 任务</a></h2> 在 Python 中任务被用来“并行的”调度协程。通过 asyncio.create_task()</code> 函数来将协程封装为一个任务，并自动调度运行</strong>。</p> import</span> time</span></span> import</span> asyncio</span></span> </span> async def</span> foo</span>(</span>i</span>):</span></span> print</span>(</span>f</span>'Running foo </span>{</span>i</span>}</span>'</span>)</span></span> await</span> asyncio.sleep(</span>1</span>)</span></span> print</span>(</span>f</span>'End foo </span>{</span>i</span>}</span>'</span>)</span></span> </span> async def</span> main</span>():</span></span> print</span>(</span>f</span>"Started at </span>{</span>time.strftime(</span>'</span>%X</span>'</span>)</span>}</span>"</span>)</span></span> task_list = []</span></span> for</span> i</span> in</span> range</span>(</span>10</span>):</span></span> task_list.append(asyncio.create_task(foo(i)))</span></span> for</span> task</span> in</span> task_list:</span></span> print</span>(</span>await</span> task)</span></span> print</span>(</span>f</span>"Finished at </span>{</span>time.strftime(</span>'</span>%X</span>'</span>)</span>}</span>"</span>)</span></span> </span> asyncio.run(main())</span></span></code></pre> 运行上述代码，会发现，程序只用了 1 秒就运行完成了。</p> 我们来具体解读一下，首先在 main()</code> 协程中先创建了 10 个任务，并储存在 task_list</code> 列表中，然后再依次等待这些任务完成。</p> 如果没有后面的等待的话，程序就会在那些任务还没有完成的情况下结束。如：</p> import</span> time</span></span> import</span> asyncio</span></span> </span> async def</span> foo</span>(</span>i</span>):</span></span> print</span>(</span>f</span>'Running foo </span>{</span>i</span>}</span>'</span>)</span></span> await</span> asyncio.sleep(</span>1</span>)</span></span> print</span>(</span>f</span>'End foo </span>{</span>i</span>}</span>'</span>)</span></span> </span> async def</span> main</span>():</span></span> print</span>(</span>f</span>"Started at </span>{</span>time.strftime(</span>'</span>%X</span>'</span>)</span>}</span>"</span>)</span></span> for</span> i</span> in</span> range</span>(</span>10</span>):</span></span> asyncio.create_task(foo(i))</span></span> print</span>(</span>f</span>"Finished at </span>{</span>time.strftime(</span>'</span>%X</span>'</span>)</span>}</span>"</span>)</span></span> </span> asyncio.run(main())</span></span></code></pre> 因为最外层是 asyncio.run(main())</code> 当 main()</code> 协程执行完毕程序就会结束，而不会管其他任务是否已经完成。</p> Python 还提供了一个函数用于替代上面的写法：</p> import</span> time</span></span> import</span> asyncio</span></span> </span> async def</span> foo</span>(</span>i</span>):</span></span> print</span>(</span>f</span>'Running foo </span>{</span>i</span>}</span>'</span>)</span></span> await</span> asyncio.sleep(</span>1</span>)</span></span> print</span>(</span>f</span>'End foo </span>{</span>i</span>}</span>'</span>)</span></span> return</span> i +</span> 1</span></span> </span> async def</span> main</span>():</span></span> print</span>(</span>f</span>"Started at </span>{</span>time.strftime(</span>'</span>%X</span>'</span>)</span>}</span>"</span>)</span></span> coroutine_list = [foo(i)</span> for</span> i</span> in</span> range</span>(</span>10</span>)]</span></span> result =</span> await</span> asyncio.gather(coroutine_list)</span></span> print</span>(result)</span></span> print</span>(</span>f</span>"Finished at </span>{</span>time.strftime(</span>'</span>%X</span>'</span>)</span>}</span>"</span>)</span></span> </span> asyncio.run(main())</span></span></code></pre> tip </div> Tip</strong></span> </div> asyncio.gather()</code> 的内部实现和之前的代码并不相同，只是效果类似。</p> </div> </div> 上面所有例子中的 asyncio.sleep(1)</code> 都可以换成真实的 IO 操作，比如下面的使用 httpx</code> 库获取网页的例子。</p> import</span> time</span></span> import</span> asyncio</span></span> import</span> httpx</span></span> </span> async def</span> foo</span>(</span>i</span>):</span></span> print</span>(</span>f</span>'Running foo </span>{</span>i</span>}</span>'</span>)</span></span> async with</span> httpx.AsyncClient()</span> as</span> client:</span></span> r =</span> await</span> client.get(</span>'https://www.example.org/'</span>)</span></span> print</span>(</span>f</span>'End foo </span>{</span>i</span>}</span>'</span>)</span></span> return</span> r</span></span> </span> async def</span> main</span>():</span></span> print</span>(</span>f</span>"Started at </span>{</span>time.strftime(</span>'</span>%X</span>'</span>)</span>}</span>"</span>)</span></span> coroutine_list = [foo(i)</span> for</span> i</span> in</span> range</span>(</span>10</span>)]</span></span> result =</span> await</span> asyncio.gather(coroutine_list)</span></span> print</span>(result)</span></span> print</span>(</span>f</span>"Finished at </span>{</span>time.strftime(</span>'</span>%X</span>'</span>)</span>}</span>"</span>)</span></span> </span> asyncio.run(main())</span></span></code></pre> 再次强调，协程不是多线程，上面的所有操作都是在一个线程中完成的，它之所以可以实现类似于并行执行的效果，是因为它没有等待 IO 操作完成，在上面的例子中程序发送了对 https://www.example.org/</code> 的第一次请求后，没有等待服务器响应，而是挂起了当前任务，于是第二个任务拿到了控制权，并进行了第二次网络请求，以此类推，这些发送请求全都发生在很短的时间内，然后当其中一个任务的请求有了回应，这个任务便会被唤醒，并继续执行剩下的代码。</p> 你会发现，这种多个任务“并行”执行的方式很像之前提到的在只有一个 CPU 的情况下多线程的模式，使用协程的好处与多线程这种让系统去调度每个线程何时运行相比，我们可以自己决定何时切换任务，更加的高效和灵活，即只在发生需要耗费时间的 IO 操作时我们使用 await</code> 等待它完成并挂起当前任务，切换至未处理的任务。</p> 我们可以用下图清晰地表示使用多线程和协程任务进行并发处理的不同：</p> gantt dateFormat DD axisFormat %d todayMarker off title 协程任务 section Task 1 网络请求 :crit, done, task11, 01, 1d 等待响应 : active, task12, after task11, 15d 处理响应 :crit, done, task13, after task12, 1d section Task 2 网络请求 :crit, done, task21, 02, 1d 等待响应 : active, task22, after task21, 15d 处理响应 :crit, done, task23, after task22, 1d section Task 3 网络请求 :crit, done, task31, 03, 1d 等待响应 : active, task32, after task31, 15d 处理响应 :crit, done, task33, after task32, 1d </pre> gantt dateFormat DD axisFormat %d todayMarker off title 多线程/多进程（线程/进程数 < CPU 核心数） section Task 1 网络请求 :crit, done, task11, 01, 1d 等待响应 : active, task12, after task11, 15d 处理响应 :crit, done, task13, after task12, 1d section Task 2 网络请求 :crit, done, task21, 01, 1d 等待响应 : active, task22, after task21, 15d 处理响应 :crit, done, task23, after task22, 1d section Task 3 网络请求 :crit, done, task31, 01, 1d 等待响应 : active, task32, after task31, 15d 处理响应 :crit, done, task33, after task32, 1d </pre> 看上面的图，你可能觉得还是多线程效率更高些，但事实并非如此，首先，上面的图并非真实的比例，真实情况下，等待响应的时间会远远大于网络请求和处理响应的时间，上面的差距可以忽略不计。其次，上面的图有一个前提就是线程/进程数小于 CPU 核心数，若大于的话也并不会进一步提高效率，往往并行 IO 操作数量都是大于用户的 CPU 核心数的。最后，切换进程是会耗费额外的资源的，相比之下，协程切换任务的消耗则要小一些。</p> 总结</a></h2> 同步 IO 和异步 IO</strong></p> 同步 IO 在进行 IO 操作时会阻塞当前进程，而异步 IO 则不阻塞。</p> </li> 可等待对象</strong></p> graph TD; 可等待对象-->A[协程 coroutine]; 可等待对象-->B[任务 Task]; 可等待对象-->C[Future]; </pre> 任务 (Task) 是由协程 (coroutine) 使用 asyncio.create_task()</code> 函数封装而成的，用于并行调度协程。</p> </li> 运行一个协程</strong></p> asyncio.run()</code> 函数：用于运行最高级入口点，如 main()</code> 协程。</li> await</code> 语句：等待一个协程，等待这个协程返回结果后继续运行下面代码。</li> asyncio.create_task()</code> 函数：将一个协程包装为一个任务并且并发地调度协程。</li> </ul> </li> </ol> note </div> Note</strong></span> </div> 如果你使用了异步 IO，请尽量在程序的所有地方都使用协程，网络请求等 IO 库也要使用支持异步 IO 的库，如 aiohttp</a>，httpx</a> 等。</p> </div> </div> 参考</a></h2> 建议参考以下内容：</p> 协程与任务 - Python 文档</a></li> 同步原语 - Python 文档</a></li> 事件循环 - Python 文档</a></li> </ul> C 语言小技巧 st1020 — Thu, 03 Dec 2020 00:00:00 +0000 C 语言有许多可以提高编程效率，简化代码，提高代码可读性的小技巧。这里列出几个小技巧及其应用，抛砖引玉，供大家参考。</p> 逗号运算符</a></h2> C 语言提供了一种特殊的运算符——逗号运算符，又称顺序求值运算符，可以用它将两个表达式连接起来。</p> 逗号表达式的一般形式如下：</p> Exp1, Exp2</span></span></code></pre> 其计算过程为：</p> 先计算 Exp1</code>，再计算 Exp2，然后将 Exp2</code> 的返回值作为整个逗号表达式的值。</p> 如 1+1, 2+2</code>，这个表达式的值是 4。</p> 需要注意，逗号运算符的优先级是所有运算符中最低的，比如：</p> a =</span> 1</span> +</span> 2</span>,</span> 3</span> </span> 4</span>;</span></span></code></pre> 表示将变量 a</code> 赋值为 1+2</code>，然后计算 3*4</code> 作为整个表达式的值，但这个值并没有被使用。</p> 所以，这个表达式有什么用呢？</p> 可以看以下几个例子：</p> #include</span> <stdio.h></span></span> </span> int</span> main</span>() {</span></span> int</span> n;</span></span> while</span> (</span>scanf</span>(</span>"</span>%d</span>"</span>, &n), n) {</span></span> printf</span>(</span>"</span>%d</span>\n</span>"</span>, n);</span></span> }</span></span> return</span> 0</span>;</span></span> }</span></span></code></pre> 如果不用逗号表达式，上述代码就需要写成：</p> #include</span> <stdio.h></span></span> </span> int</span> main</span>() {</span></span> int</span> n =</span> 1</span>;</span></span> while</span> (n) {</span></span> scanf</span>(</span>"</span>%d</span>"</span>, &n);</span></span> printf</span>(</span>"</span>%d</span>\n</span>"</span>, n);</span></span> }</span></span> return</span> 0</span>;</span></span> }</span></span></code></pre> 还有：</p> #include</span> <stdio.h></span></span> </span> int</span> main</span>() {</span></span> int</span> n;</span></span> scanf</span>(</span>"</span>%d</span>"</span>, &n);</span></span> for</span> (</span>int</span> i =</span> 0</span>, j = n; i < j; ++i, --j) {</span></span> printf</span>(</span>"</span>%d %d %d</span>\n</span>"</span>, n, i, j);</span></span> }</span></span> return</span> 0</span>;</span></span> }</span></span></code></pre> 如果不用逗号表达式，上述代码就需要写成：</p> #include</span> <stdio.h></span></span> </span> int</span> main</span>() {</span></span> int</span> n;</span></span> scanf</span>(</span>"</span>%d</span>"</span>, &n);</span></span> for</span> (</span>int</span> i =</span> 0</span>, j = n; i < j; ++i) {</span></span> printf</span>(</span>"</span>%d %d %d</span>\n</span>"</span>, n, i, j);</span></span> --j;</span></span> }</span></span> return</span> 0</span>;</span></span> }</span></span></code></pre> 多了一行……好吧，实际上都没有多多少代码，但能少一行是一行嘛，并且，这样写代码的可读性提高了不少。</p> 数组的部分初始化</a></h2> 当我们声明一个数组并对其进行初始化时，我们可以仅对其部分进行初始化，如：</p> int</span> arr</span>[]</span> = {[</span>1</span>]=</span>5</span>, [</span>5</span>]=</span>10</span>, [</span>2</span>]=</span>20</span>};</span></span> int</span> arr2</span>[]</span> = {[</span>0</span> ... </span>9</span>] =</span> 10</span>, [</span>10</span> ... </span>19</span>] =</span> 20</span>, [</span>20</span> ... </span>29</span>] =</span> 30</span>};</span></span></code></pre> 上面的例子很简单，应该没有什么可说的，这也算是 C 语言的一个很少有人知道的一个小特性吧。</p> C 语言的预处理器</a></h2> C 语言的预处理器不是编译器的组成部分，而是编译过程中一个单独的步骤。实际上，我们可以把它理解为一个在开始编译源码之前的一个文本替换工具。最常用的预处理指令就是 #include</code>，用于包含另一个源码文件，当我们在程序开头加上下面这行时，</p> #include</span> <stdio.h></span></span></code></pre> 预处理器就会在程序开始的地方引入 stdio.h</code> 的全部内容，这样我们就可以使用这个头文件中包含的函数了。</p> 另一个常用的预处理指令就是 #define</code>，定义宏，如</p> #define</span> PI</span> 3.1415927</span></span></code></pre> 实际上就是将下面所有出现 PI</code> 的地方替换为 3.1415927</code>。</p> 完整的预处理指令如下：</p> 指令</th> 描述</th></tr></thead> #define</td> 定义宏</td></tr> #include</td> 包含一个源代码文件</td></tr> #undef</td> 取消已定义的宏</td></tr> #ifdef</td> 如果宏已经定义，则返回真</td></tr> #ifndef</td> 如果宏没有定义，则返回真</td></tr> #if</td> 如果给定条件为真，则编译下面代码</td></tr> #else</td> #if 的替代方案</td></tr> #elif</td> 如果前面的 #if 给定条件不为真，当前条件为真，则编译下面代码</td></tr> #endif</td> 结束一个 #if……#else 条件编译块</td></tr> #error</td> 当遇到标准错误时，输出错误消息</td></tr> #pragma</td> 使用标准化方法，向编译器发布特殊的命令到编译器中</td></tr> </tbody></table> ANSI C 标准还定义了许多宏。在编程中我们可以使用这些宏，但是不能直接修改这些预定义的宏。</p> 宏</th> 描述</th></tr></thead> __DATE__</td> 当前日期，一个以“MMM DD YYYY”格式表示的字符常量。</td></tr> __TIME__</td> 当前时间，一个以“HH:MM:SS”格式表示的字符常量。</td></tr> __FILE__</td> 这会包含当前文件名，一个字符串常量。</td></tr> __LINE__</td> 这会包含当前行号，一个十进制常量。</td></tr> __STDC__</td> 当编译器以 ANSI 标准编译时，则定义为 1。</td></tr> </tbody></table> 例：</p> #include</span> <stdio.h></span></span> </span> int</span> main</span>() {</span></span> printf</span>(</span>"File :</span>%s</span>\n</span>"</span>, __FILE__);</span></span> printf</span>(</span>"Date :</span>%s</span>\n</span>"</span>, __DATE__);</span></span> printf</span>(</span>"Time :</span>%s</span>\n</span>"</span>, __TIME__);</span></span> printf</span>(</span>"Line :</span>%d</span>\n</span>"</span>, __LINE__);</span></span> printf</span>(</span>"ANSI :</span>%d</span>\n</span>"</span>, __STDC__);</span></span> }</span></span></code></pre> 通过巧用预处理指令，我们可以有效的简化代码，比如，我们可以用预处理指令来定义求较大值、求较小值、转大写和求数组元素数的函数。</p> #define</span> MAX(</span>x</span>,</span> y</span>) (((x)</span>></span>(y))</span> ?</span> (x)</span> :</span> (y))</span></span> #define</span> MIN(</span>x</span>,</span> y</span>) (((x)</span> <</span> (y))</span> ?</span> (x)</span> :</span> (y))</span></span> #define</span> UPCASE(</span>c</span>) (((c)</span>>=</span>'a'</span> &&</span> (c)</span> <=</span> 'z'</span>)</span> ?</span> ((c)</span> -</span> 0x20</span>)</span> :</span> (c))</span></span> #define</span> ARR_SIZE(</span>a</span>) (sizeof((a))</span>/</span>sizeof((</span>a</span>[</span>0</span>])))</span></span></code></pre> Python 实现的 Brainfuck 语言解析器 st1020 — Mon, 14 Sep 2020 00:00:00 +0000 BrainFuck</a></h2> BrainFuck 语言是一种深奥的编程语言 (Esoteric programming language，Esolang)，由 Urban Müller 于 1993 年创造。目的是为了创造一个简单的、最小的、符合图灵完全的编程语言。正如它的名字，BrainFuck 因为对人类极度不友好而广为人知。但是作为一种图灵完备的编程语言，理论上任何其他编程语言能够实现的程序都可以由 BrainFuck 实现。</p> 关于停机问题与自指性悖论 st1020 — Tue, 21 Jul 2020 00:00:00 +0000 停机问题是是逻辑数学中可计算性理论的一个很经典的问题，该问题内容为：是否存在一个程序 H，对于任意输入的程序 P，能够判断 P 会在有限时间内结束或者死循环。</p> 答案是否定的，证明如下：</p> 假设停机问题有解，即存在一个程序能够判断程序 P 在输入 I 的情况下是否可停机 (即是否会进入死循环)。我们假设该程序为函数 H</code>，即：</p> def</span> H</span>(</span>P</span>,</span> I</span>) -></span> bool</span>:</span></span> pass</span></span></code></pre> 若函数 P</code> 在输入 I</code> 时不会进入死循环，则 H</code> 返回 True</code>，否则返回 False</code>。</p> 然后我们定义另一个函数 U</code>：</p> def</span> U</span>(</span>P</span>):</span></span> if</span> H(P, P):</span></span> while</span> True</span>:</span></span> pass</span></span> else</span>:</span></span> return</span></span></code></pre> 也就是说当 H</code> 判断 P(P)</code> 会停机时，U</code> 就进入死循环，否则正常返回。</p> 那么，当 U</code> 输入 U</code>，也就是 U(U)</code> 会不会停机呢？既然 H</code> 能够判断任何程序是否会停机，那么应该也能回答这个问题，也就是：</p> H(U, U)</span></span></code></pre> 那么问题就来了，如果 H</code> 认为 U(U)</code> 会停机，即 H(U, U)</code> 返回 True</code>，那么实际上 U(U)</code> 就会进入死循环，并不会停机。如果 H</code> 认为 U(U)</code> 不会停机，即 H(U, U)</code> 返回 False</code>，那么实际上 U(U)</code> 就会进入死循环，并不会停机。这就推出了矛盾，也就是说 H</code> 并不能永远给出停机问题的准确答案。</p> 由此可以证明，不存在能够判断任意程序在特定输入下是否会在有限时间内停机的程序，停机问题无解。</p> 与此类似的还有“理发师悖论”：一位理发师的原则是当且仅当一个人不为自己理发时他为其理发，那么这位理发师能为自己理发吗？这里“理发师悖论”实际上是罗素悖论的一个比喻，也即：对于集合 $A=\{x \mid x \notin A\}$ 判断 $A \in A$ 是否成立。</p> 这个悖论的根本性问题为集合的自指，所以我们只要拒绝集合的自指即可解决该问题，也就是认为不存在像 $A=\{x \mid x \notin A\}$ 的集合。</p> 同样，对于停机问题我们也可以有类似的解释，产生悖论的原因正是这个能够判断其他程序是否能停机的程序也是一个程序，那么当它判断涉及自己的程序时就可能会产生悖论，最终证明一个程序不可能判断其他所有程序是否停机。</p> 类似的还有“全能悖论”：上帝全知全能，那么祂能创造一个自己搬不起来的石头吗？如果能，那么说明其在力量方面并非全能，如果不能，说明其在创造方面并非全能。这同样是因为自指导致的悖论，当我们将上帝的全能性作用于其本身时就会导致悖论，从而说明全能的上帝是不存在的。</p> 此外还有一个最常见的悖论——“说谎者悖论”：“这个语句为假”是否为真。对此有许多解释，比如曾有人提出应拒绝与排中律有关的二值原理，也就是拒绝“所有语句要么为真要么为假”的主张，认为其非真非假。但是，对于另一个问题：“这个语句不为真”是否为真，也同样无法解决，类似的主张如认为其又真又假也存在无法回答的问题，即”这个语句只为假“是否为真。对此的解决比较好的有 Arthur Prior 提出的观点：语句都包含对自己真值的隐含断言，即“一加一等于二”隐含了“一加一等于二为真”的真值断言，任何一句话“A”都可以改写为“A 且这句话为真”，那么同样，“这句话为假”等价与“这句话为真且这句话为假”，而这句话本身就包含了矛盾，就像“这个东西是苹果且这个东西不是苹果”一样，所以说谎者悖论实质上是由一个一开始就含有矛盾的假语句而推导出的另一个矛盾，并不是一个悖论。不过我认为这实质上是从语言上回避了这个这个问题，是因为自然语言的不严谨导致的，并无法用来解释罗素悖论等其他涉及自指的悖论。</p> Powered by Hugo st1020 — Wed, 15 Jul 2020 00:00:00 +0000 由于各种原因，已经很久没有更新博客了...鸽子真快乐。总之，从今天起，本博客正式迁移至 Hugo！</p> 其实在开始建立这个博客的时候我就已经想要使用 Hugo 作为静态博客生成器了，只是一直没有找到满意的主题，所以就搁置了下来，直到最近我终于找到了一个可以说非常完美的主题：LoveIt</a>，于是果断将博客迁移到了 Hugo 上了。</p> Hugo 在很多方面都要比 Hexo 更加方便，首先，Hugo 的环境配置十分简单，只需要一个 Go 语言编译的可执行文件即可执行，而 Hexo 则需要安装 Node.js 环境。其次，Hugo 的运行速度更快，相比于 Hexo 最短也要几秒到几十秒的构建时间，Hugo 只需要几百毫秒即可完成构建。其三，Hugo 的目录配置更加合理，Hugo 的没有像 Hexo 那样的使用 node_modules 管理插件，主题目录与站点目录结构相同，文章与静态文件分开存放，不区分站点与主题配置文件，使用文件系统结构来组织文章等等。</p> 当然，Hexo 也并非一无是处，其主题资源相较 Hugo 要更加丰富，用户数量也更多。但是综合考虑我还是选择了 Hugo。</p> 最后，再见 Hexo，你好 Hugo！</p> Farewell Hexo, Hello Hugo!</p> Arch Linux 安装记录 st1020 — Wed, 08 Apr 2020 00:00:00 +0000 前几天打开好久没用的电脑，一更新把之前图省事装的 Manjaro 滚挂了，也懒得去解决，于是决定安装一个 Arch Linux，在这里记录一下安装过程。</p> 本人是非常喜欢 Arch Linux 的，因为其高度自定义化、遵循 KISS 原则 (Keep It Simple, Stupid)、滚动更新并且以用户为中心。但是，由于其理念为以用户为中心但不是用户友好，所以对很多人来说安装 Arch 还是有一定难度的。读者也可以参考本篇教程从零开始安装一个属于自己的 Arch。</p> Hexo-NexT 主题个性化定制 st1020 — Wed, 08 Apr 2020 00:00:00 +0000 本篇文章主要谈一谈我是如何个性化定制 Hexo 的 NexT 主题的。</p> Hexo 的主题有许多种，其中最知名的莫过于 NexT 主题了，我也选择了这款主题作为我的博客的默认主题。实际上，我本来是打算使用 Hugo 来搭建博客的，但苦于没有找到喜欢的主题，只好作罢。如果未来找到了足够好的主题，我应该会将博客迁移到 Hugo 上吧。本篇也是作为我折腾 Hexo 的一篇记录。</p> Hello World st1020 — Mon, 06 Apr 2020 00:00:00 +0000 Hello World!</a></h2> 今天这个博客正式建立了！</p>

简单但强大的 Pratt Parsing【译】

使用 Markdown 写论文（一）

参考资料</a></h2>

Pandoc User’s Guide</a></li>
Markdown 写作，Pandoc 转换：我的纯文本学术写作流程</a></li>
如何用 Markdown 写论文？</a></li> </ul>

Rust 中生命周期的子类型化和型变

编写现代的 Python

Powered by Zola

修复 MacOS 升级后 VSCode LLDB 调试错误

Git 重写历史和修复提交日期

参考资料</a></h2>

Git - 重写历史</a></li>
Force GIT_COMMITTER_DATE = GIT_AUTHOR_DATE</a></li>
Git - git-filter-branch Documentation</a></li>
Git - pretty-formats Documentation</a></li>
Git - git-commit Documentation - COMMIT INFORMATION</a></li> </ul>

Python 异步 IO 实用教程

参考</a></h2>
建议参考以下内容：</p>

协程与任务 - Python 文档</a></li>
同步原语 - Python 文档</a></li>
事件循环 - Python 文档</a></li> </ul>

C 语言小技巧

Python 实现的 Brainfuck 语言解析器

关于停机问题与自指性悖论

Powered by Hugo

Arch Linux 安装记录

Hexo-NexT 主题个性化定制

Hello World

Hello World!</a></h2>
今天这个博客正式建立了！</p>

石头的杂货铺

理解代理

石头的杂货铺

理解代理

简单但强大的 Pratt Parsing【译】

使用 Markdown 写论文（一）

Rust 中生命周期的子类型化和型变

编写现代的 Python

Powered by Zola

修复 MacOS 升级后 VSCode LLDB 调试错误

Git 重写历史和修复提交日期

Python 异步 IO 实用教程

总结</a></h2> 同步 IO 和异步 IO</strong></p> 同步 IO 在进行 IO 操作时会阻塞当前进程，而异步 IO 则不阻塞。</p> </li>

C 语言小技巧

Python 实现的 Brainfuck 语言解析器

关于停机问题与自指性悖论

Powered by Hugo

Arch Linux 安装记录

Hexo-NexT 主题个性化定制

Hello World