Assertions

Author: dumindu

content/en/docs/e2.panicking.md

@@ -14,16 +14,20 @@ slug: panicking
     - Default panic message/prefix: `internal error: entered unreachable code`
   - Assertions
     - Mainly used with test assertions and ensure runtime conditions true.
-    - `assert!`, `assert_eq!` and `assert_ne!`: Standard runtime assertions evaluated in both debug and release builds.
-    - `debug_assert!`, `debug_assert_eq!` and `debug_assert_ne!`: Mirrors to standard assertions that run only in debug builds and are omitted from release builds.
-    - Default panic message: `assertion failed:` or ```assertion `left != right` failed```
+    - `assert!`/ `debug_assert!`: Ensures a condition is true.
+      - Default panic message: `assertion failed`
+    - `assert_eq!`/ `debug_assert_eq!` and `assert_ne!`/ `debug_assert_ne!`: Ensures two expressions are equal or not equal.
+      - Default panic message/prefix: ```assertion `left != right` failed```
+    - `assert_matches!`/ `debug_assert_matches!`: Ensures an expression matches a given pattern.
+      - Default panic message/prefix: ```assertion `left matches right` failed```
+      - Non-prelude assertions to replace `assert!(matches!(value, pattern))`
+    
 - Rust cleans up memory by destroying variables on the stack in reverse order after a panic occurs. This process is called Unwinding.
 
 ## `panic!`
 
-Mainly used with unrecoverable errors.
-
-In single threaded applications, the program will print an error message, clean up its memory with unwinding, and crash at runtime. In multithreaded applications, a panic affects only on the thread that occurred.
+- Mainly used with unrecoverable errors.
+- In single threaded applications, the program will print an error message, clean up its memory with unwinding, and crash at runtime. In multithreaded applications, a panic affects only on the thread that occurred.
 
 ### Default Message
 
@@ -100,8 +104,7 @@ fn main() {
 
 ## `todo!` and `unimplemented!`
 
-The difference is quite semantic. 
-
+The difference is quite semantic,\
 `todo!` indicates that we plan to add the code later, while `unimplemented!` only means the code is unimplemented.
 
 ```rust
@@ -185,7 +188,10 @@ fn main() {
 
 ## Assertions
 
-Similar to the panic!, this also support custom messages and values.
+- Mainly used with test assertions and ensure runtime conditions true.
+  - `assert*`: Standard runtime assertions evaluated in both debug and release builds.
+  - `debug_assert*`: Mirrors to standard assertions that run only in debug builds and are omitted from release builds.
+- Similar to the `panic!`, these also support custom messages and values.
 
 ### `assert!` & `debug_assert!`
 
@@ -289,12 +295,14 @@ fn main() {
 
 Ensures an expression matches a given pattern.
 
+> [!tip]
+> Non-prelude assertions to replace `assert!(matches!(value, pattern))`
+
 ```rust
 fn main() {
     let a = Some(10);
     std::assert_matches!(a, Some(x) if x > 20); // or debug_assert_matches!
 }
-// 💡 assert_matches! and debug_assert_matches! are not in Rust preludes
 ```
 
 > [!Caution] Crash at Runtime

docs/docs/index.xml

@@ -604,7 +604,8 @@ __ <a href="https://wiki.haskell.org/Combinator" target="_blank" >wiki.has
 </span></span></span><span class="line"><span class="cl"><span class="w"> </span><span class="o">|</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="k">move</span><span class="w"> </span><span class="n">occurs</span><span class="w"> </span><span class="n">because</span><span class="w"> </span><span class="err">`</span><span class="n">a</span><span class="err">`</span><span class="w"> </span><span class="n">has</span><span class="w"> </span><span class="k">type</span> <span class="err">`</span><span class="n">Point</span><span class="err">`</span><span class="p">,</span><span class="w"> </span><span class="n">which</span><span class="w"> </span><span class="n">does</span><span class="w"> </span><span class="n">not</span><span class="w"> </span><span class="n">implement</span><span class="w"> </span><span class="n">the</span><span class="w"> </span><span class="err">`</span><span class="nb">Copy</span><span class="err">`</span><span class="w"> </span><span class="k">trait</span><span class="w">
 </span></span></span><span class="line"><span class="cl"><span class="w"> </span><span class="mi">9</span><span class="w"> </span><span class="o">|</span><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">b</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">a</span><span class="p">;</span><span class="w">
 &lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;|&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;moved&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;here&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;This is because of Ownership, which is used to achieve Rust&amp;rsquo;s memory safety.&lt;/p&gt;</description></item><item><title>Panicking</title><link>https://learning-rust.github.io/docs/panicking/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://learning-rust.github.io/docs/panicking/</guid><description>&lt;ul&gt;
-&lt;li&gt;Panicking immediately terminates the current thread.
+&lt;li&gt;
+&lt;p&gt;Panicking immediately terminates the current thread.&lt;/p&gt;
 &lt;ul&gt;
 &lt;li&gt;&lt;code&gt;panic!&lt;/code&gt;: Mainly used with unrecoverable errors.
 &lt;ul&gt;
@@ -629,17 +630,28 @@ __ &lt;a href="https://wiki.haskell.org/Combinator" target="_blank" &gt;wiki.has
 &lt;li&gt;Assertions
 &lt;ul&gt;
 &lt;li&gt;Mainly used with test assertions and ensure runtime conditions true.&lt;/li&gt;
-&lt;li&gt;&lt;code&gt;assert!&lt;/code&gt;, &lt;code&gt;assert_eq!&lt;/code&gt; and &lt;code&gt;assert_ne!&lt;/code&gt;: Standard runtime assertions evaluated in both debug and release builds.&lt;/li&gt;
-&lt;li&gt;&lt;code&gt;debug_assert!&lt;/code&gt;, &lt;code&gt;debug_assert_eq!&lt;/code&gt; and &lt;code&gt;debug_assert_ne!&lt;/code&gt;: Mirrors to standard assertions that run only in debug builds and are omitted from release builds.&lt;/li&gt;
-&lt;li&gt;Default panic message: &lt;code&gt;assertion failed:&lt;/code&gt; or &lt;code&gt;assertion `left != right` failed&lt;/code&gt;&lt;/li&gt;
+&lt;li&gt;&lt;code&gt;assert!&lt;/code&gt;/ &lt;code&gt;debug_assert!&lt;/code&gt;: Ensures a condition is true.
+&lt;ul&gt;
+&lt;li&gt;Default panic message: &lt;code&gt;assertion failed&lt;/code&gt;&lt;/li&gt;
+&lt;/ul&gt;
+&lt;/li&gt;
+&lt;li&gt;&lt;code&gt;assert_eq!&lt;/code&gt;/ &lt;code&gt;debug_assert_eq!&lt;/code&gt; and &lt;code&gt;assert_ne!&lt;/code&gt;/ &lt;code&gt;debug_assert_ne!&lt;/code&gt;: Ensures two expressions are equal or not equal.
+&lt;ul&gt;
+&lt;li&gt;Default panic message/prefix: &lt;code&gt;assertion `left != right` failed&lt;/code&gt;&lt;/li&gt;
+&lt;/ul&gt;
+&lt;/li&gt;
+&lt;li&gt;&lt;code&gt;assert_matches!&lt;/code&gt;/ &lt;code&gt;debug_assert_matches!&lt;/code&gt;: Ensures an expression matches a given pattern.
+&lt;ul&gt;
+&lt;li&gt;Default panic message/prefix: &lt;code&gt;assertion `left matches right` failed&lt;/code&gt;&lt;/li&gt;
+&lt;li&gt;Non-prelude assertions to replace &lt;code&gt;assert!(matches!(value, pattern))&lt;/code&gt;&lt;/li&gt;
 &lt;/ul&gt;
 &lt;/li&gt;
 &lt;/ul&gt;
 &lt;/li&gt;
-&lt;li&gt;Rust cleans up memory by destroying variables on the stack in reverse order after a panic occurs. This process is called Unwinding.&lt;/li&gt;
 &lt;/ul&gt;
-&lt;h2 id="panic"&gt;&lt;code&gt;panic!&lt;/code&gt;&lt;/h2&gt;
-&lt;p&gt;Mainly used with unrecoverable errors.&lt;/p&gt;</description></item><item><title>Primitive Data Types</title><link>https://learning-rust.github.io/docs/primitive-data-types/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://learning-rust.github.io/docs/primitive-data-types/</guid><description>&lt;h2 id="bool"&gt;bool&lt;/h2&gt;
+&lt;/li&gt;
+&lt;li&gt;
+&lt;p&gt;Rust cleans up memory by destroying variables on the stack in reverse order after a panic occurs. This process is called Unwinding.&lt;/p&gt;</description></item><item><title>Primitive Data Types</title><link>https://learning-rust.github.io/docs/primitive-data-types/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://learning-rust.github.io/docs/primitive-data-types/</guid><description>&lt;h2 id="bool"&gt;bool&lt;/h2&gt;
 &lt;p&gt;true or false&lt;/p&gt;