Fix some issues in docs.

Author: hzhangxyz

docs/concepts/search.md

@@ -22,18 +22,6 @@ The search engine:
 
 ## Creating a Search Engine
 
-=== "Python"
-
-    ```python
-    import apyds
-
-    # Create with default sizes
-    search = apyds.Search()
-
-    # Create with custom sizes
-    search = apyds.Search(limit_size=1000, buffer_size=10000)
-    ```
-
 === "TypeScript"
 
     ```typescript
@@ -46,6 +34,18 @@ The search engine:
     const search2 = new Search(1000, 10000);
     ```
 
+=== "Python"
+
+    ```python
+    import apyds
+
+    # Create with default sizes
+    search = apyds.Search()
+
+    # Create with custom sizes
+    search = apyds.Search(limit_size=1000, buffer_size=10000)
+    ```
+
 === "C++"
 
     ```cpp
@@ -64,20 +64,6 @@ The search engine:
 
 Use the `add()` method to add rules and facts to the knowledge base.
 
-=== "Python"
-
-    ```python
-    import apyds
-
-    search = apyds.Search()
-
-    # Add a fact
-    search.add("(parent john mary)")
-
-    # Add a rule with premises
-    search.add("(father `X `Y)\n----------\n(parent `X `Y)\n")
-    ```
-
 === "TypeScript"
 
     ```typescript
@@ -92,6 +78,20 @@ Use the `add()` method to add rules and facts to the knowledge base.
     search.add("(father `X `Y)\n----------\n(parent `X `Y)\n");
     ```
 
+=== "Python"
+
+    ```python
+    import apyds
+
+    search = apyds.Search()
+
+    # Add a fact
+    search.add("(parent john mary)")
+
+    # Add a rule with premises
+    search.add("(father `X `Y)\n----------\n(parent `X `Y)\n")
+    ```
+
 === "C++"
 
     ```cpp
@@ -108,6 +108,23 @@ Use the `add()` method to add rules and facts to the knowledge base.
 
 The `execute()` method performs one round of inference. It matches all rules against all facts and generates new conclusions.
 
+=== "TypeScript"
+
+    ```typescript
+    import { Search } from "atsds";
+
+    const search = new Search();
+    search.add("(father `X `Y)\n----------\n(parent `X `Y)\n");
+    search.add("(father john mary)");
+
+    const count = search.execute((rule) => {
+        console.log(`Found: ${rule.toString()}`);
+        return false;  // Continue searching
+    });
+
+    console.log(`Generated ${count} new facts`);
+    ```
+
 === "Python"
 
     ```python
@@ -126,23 +143,6 @@ The `execute()` method performs one round of inference. It matches all rules aga
     print(f"Generated {count} new facts")
     ```
 
-=== "TypeScript"
-
-    ```typescript
-    import { Search } from "atsds";
-
-    const search = new Search();
-    search.add("(father `X `Y)\n----------\n(parent `X `Y)\n");
-    search.add("(father john mary)");
-
-    const count = search.execute((rule) => {
-        console.log(`Found: ${rule.toString()}`);
-        return false;  // Continue searching
-    });
-
-    console.log(`Generated ${count} new facts`);
-    ```
-
 === "C++"
 
     ```cpp
@@ -169,36 +169,6 @@ The callback receives each newly inferred rule and should return:
 
 To search until a specific target is found:
 
-=== "Python"
-
-    ```python
-    import apyds
-
-    search = apyds.Search(1000, 10000)
-
-    # Set up propositional logic
-    search.add("(`P -> `Q) `P `Q")  # Modus ponens
-    search.add("(`p -> (`q -> `p))")  # Axiom 1
-    search.add("((`p -> (`q -> `r)) -> ((`p -> `q) -> (`p -> `r)))")  # Axiom 2
-    search.add("(((! `p) -> (! `q)) -> (`q -> `p))")  # Axiom 3
-    search.add("(! (! X))")  # Premise
-
-    target = apyds.Rule("X")
-
-    while True:
-        found = False
-        def check(candidate):
-            nonlocal found
-            if candidate == target:
-                print(f"Found: {candidate}")
-                found = True
-                return True
-            return False
-        search.execute(check)
-        if found:
-            break
-    ```
-
 === "TypeScript"
 
     ```typescript
@@ -229,24 +199,54 @@ To search until a specific target is found:
     }
     ```
 
-## Configuration Methods
+=== "Python"
 
-### Set Limit Size
+    ```python
+    import apyds
 
-Controls the maximum size for each stored rule/fact:
+    search = apyds.Search(1000, 10000)
 
-=== "Python"
+    # Set up propositional logic
+    search.add("(`P -> `Q) `P `Q")  # Modus ponens
+    search.add("(`p -> (`q -> `p))")  # Axiom 1
+    search.add("((`p -> (`q -> `r)) -> ((`p -> `q) -> (`p -> `r)))")  # Axiom 2
+    search.add("(((! `p) -> (! `q)) -> (`q -> `p))")  # Axiom 3
+    search.add("(! (! X))")  # Premise
 
-    ```python
-    search.set_limit_size(2000)
+    target = apyds.Rule("X")
+
+    while True:
+        found = False
+        def check(candidate):
+            global found
+            if candidate == target:
+                print(f"Found: {candidate}")
+                found = True
+                return True
+            return False
+        search.execute(check)
+        if found:
+            break
     ```
 
+## Configuration Methods
+
+### Set Limit Size
+
+Controls the maximum size for each stored rule/fact:
+
 === "TypeScript"
 
     ```typescript
     search.set_limit_size(2000);
     ```
 
+=== "Python"
+
+    ```python
+    search.set_limit_size(2000)
+    ```
+
 === "C++"
 
     ```cpp
@@ -257,18 +257,18 @@ Controls the maximum size for each stored rule/fact:
 
 Controls the internal buffer size for operations:
 
-=== "Python"
-
-    ```python
-    search.set_buffer_size(20000)
-    ```
-
 === "TypeScript"
 
     ```typescript
     search.set_buffer_size(20000);
     ```
 
+=== "Python"
+
+    ```python
+    search.set_buffer_size(20000)
+    ```
+
 === "C++"
 
     ```cpp
@@ -279,18 +279,18 @@ Controls the internal buffer size for operations:
 
 Clears all rules and facts:
 
-=== "Python"
-
-    ```python
-    search.reset()
-    ```
-
 === "TypeScript"
 
     ```typescript
     search.reset();
     ```
 
+=== "Python"
+
+    ```python
+    search.reset()
+    ```
+
 === "C++"
 
     ```cpp

docs/examples/basic.md

@@ -40,7 +40,7 @@ Given the premise ¬¬X (double negation of X), we can derive X.
     while True:
         found = False
         def callback(candidate):
-            nonlocal found
+            global found
             if candidate == target:
                 print("Found:", candidate)
                 found = True

docs/getting-started/quickstart.md

@@ -105,7 +105,7 @@ Rules represent logical inference steps. A rule has premises (conditions) and a
         auto rule = ds::text_to_rule("(father `X `Y)\n----------\n(parent `X `Y)\n", 1000);
 
         std::cout << "Rule premises: " << rule->premises_count() << std::endl;
-        std::cout << "Rule conclusion: " << ds::rule_to_text(fact->conclusion(), 1000).get() << std::endl;
+        std::cout << "Rule conclusion: " << ds::term_to_text(fact->conclusion(), 1000).get() << std::endl;
         return 0;
     }
     ```
@@ -140,7 +140,7 @@ The search engine performs logical inference by matching rules with facts.
     while True:
         found = False
         def callback(candidate):
-            nonlocal found
+            global found
             if candidate == target:
                 print(f"Found: {candidate}")
                 found = True