Introduce pattern matching support

Author: skylee03

course9/course_en.md

@@ -333,6 +333,27 @@ fn init {
 
 ---
 
+# Pattern Matching
+
+- The type must implement the `op_get` method, where the key is a native type and the value is an `Option[T]`.
+- When matching, the key must be a literal.
+- In `{ "key": pat }`, the pattern pat type is `Option[T]`.
+- Unmatched keys will be ignored even if they exist.
+- The code generated is optimized, with each key being queried at most once.
+
+```moonbit
+fn init {
+  let empty: Map[Int, Int] = make()
+  let one = { empty[1] = 1 }
+  match one {
+    { 2 : Some(y) } => println(y)
+    { 2 : None, 1 : Some(k) } => println(k)
+  }
+}
+```
+
+---
+
 # Summary
 
 - In this chapter, we learned how to

course9/lecture_en.md

@@ -292,6 +292,21 @@ fn init {
 
 In the previous example, the assignment statement is essentially an expression, and the return value is determined by the `op_get` method. We can use this method to retrieve the updated value. For mutable data structures, we also have the option to modify them in place without returning any value.
 
+With the implementation of `op_get`, we can introduce pattern matching support to `Map`. This feature is applicable when the key is a native type and the value is an `Option[T]`.
+
+```moonbit
+fn init {
+  let empty: Map[Int, Int] = make()
+  let one = { empty[1] = 1 }
+  match one {
+    { 2 : Some(y) } => println(y)
+    { 2 : None, 1 : Some(k) } => println(k)
+  }
+}
+```
+
+When matching, it is important to note that the key needs to be a literal value. In `{ "key": pat }`, the type of the pattern `pat` should be `Option[T]`. It is worth mentioning that the key-value pair pattern is open, meaning that any unmatched keys will be ignored even if they exist. Additionally, the code generated for key-value pair patterns is optimized, ensuring that each key is only queried at most once.
+
 # Summary
 
 In this chapter, we learned how to