From c457ac16c5740b65b49e592617bedb27a0d216ac Mon Sep 17 00:00:00 2001 From: Nilstrieb Date: Fri, 17 Mar 2023 16:05:29 +0000 Subject: [PATCH] deploy: 47f40f231ac89cefb376ba36980e1380cc1f374e --- index.html | 4 +- index.xml | 165 +++++++++++++++++- posts/box-is-a-unique-type/index.html | 3 +- posts/index.html | 4 +- posts/index.xml | 165 +++++++++++++++++- .../item-patterns-and-struct-else/index.html | 131 ++++++++++++++ sitemap.xml | 2 +- tags/index.html | 2 +- tags/index.xml | 2 +- tags/language-design/index.html | 5 + tags/language-design/index.xml | 164 +++++++++++++++++ tags/language-design/page/1/index.html | 1 + tags/rust/index.html | 4 +- tags/rust/index.xml | 165 +++++++++++++++++- 14 files changed, 807 insertions(+), 10 deletions(-) create mode 100644 posts/item-patterns-and-struct-else/index.html create mode 100644 tags/language-design/index.html create mode 100644 tags/language-design/index.xml create mode 100644 tags/language-design/page/1/index.html diff --git a/index.html b/index.html index db1bd80..1ca4590 100644 --- a/index.html +++ b/index.html @@ -1,4 +1,6 @@ -nilstriebs blog

Box Is a Unique Type

2022-07-23 +nilstriebs blog

Item Patterns And Struct Else

2023-03-17 +:: Nilstrieb
#rust  +#language-design 
Bringing more expressiveness to our items

Box Is a Unique Type

2022-07-23 :: Nilstrieb
#rust  #unsafe code 
About better aliasing semantics for Box<T>
© 2023 Powered by Hugo :: Theme made by panr
diff --git a/index.xml b/index.xml index ee81ea0..bdd451f 100644 --- a/index.xml +++ b/index.xml @@ -1,4 +1,167 @@ -nilstriebs blog/Recent content on nilstriebs blogHugo -- gohugo.ioen-usSat, 23 Jul 2022 00:00:00 +0000Box Is a Unique Type/posts/box-is-a-unique-type/Sat, 23 Jul 2022 00:00:00 +0000/posts/box-is-a-unique-type/We have all used Box&lt;T&gt; before in our Rust code. It&rsquo;s a glorious type, with great ergonomics and flexibility. We can use it to put our values on the heap, but it can do even more than that! +nilstriebs blog/Recent content on nilstriebs blogHugo -- gohugo.ioen-usFri, 17 Mar 2023 00:00:00 +0000Item Patterns And Struct Else/posts/item-patterns-and-struct-else/Fri, 17 Mar 2023 00:00:00 +0000/posts/item-patterns-and-struct-else/Pattern matching One of my favourite features of Rust is pattern matching. It&rsquo;s a simple and elegant way to deal with not just structs, but also enums! +enum ItemKind { Struct(String, Vec&lt;Field&gt;), Function(String, Body), } impl ItemKind { fn name(&amp;self) -&gt; &amp;str { match self { Self::Struct(name, _) =&gt; name, Self::Function(name, _) =&gt; name, } } } Here, we have an enum and a function to get the name out of this.<h1 id="pattern-matching">Pattern matching</h1> +<p>One of my favourite features of Rust is pattern matching. It&rsquo;s a simple and elegant way to deal with not just structs, but also enums!</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">enum</span> <span style="color:#a6e22e">ItemKind</span> { +</span></span><span style="display:flex;"><span> Struct(String, Vec<span style="color:#f92672">&lt;</span>Field<span style="color:#f92672">&gt;</span>), +</span></span><span style="display:flex;"><span> Function(String, Body), +</span></span><span style="display:flex;"><span>} +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span><span style="color:#66d9ef">impl</span> ItemKind { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">fn</span> <span style="color:#a6e22e">name</span>(<span style="color:#f92672">&amp;</span>self) -&gt; <span style="color:#66d9ef">&amp;</span><span style="color:#66d9ef">str</span> { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">match</span> self { +</span></span><span style="display:flex;"><span> Self::Struct(name, _) <span style="color:#f92672">=&gt;</span> name, +</span></span><span style="display:flex;"><span> Self::Function(name, _) <span style="color:#f92672">=&gt;</span> name, +</span></span><span style="display:flex;"><span> } +</span></span><span style="display:flex;"><span> } +</span></span><span style="display:flex;"><span>} +</span></span></code></pre></div><p>Here, we have an enum and a function to get the name out of this. In C, this would be very unsafe, as we cannot be guaranteed that our union has the right tag. +But in Rust, the compiler nicely checks it all for us. It&rsquo;s safe and expressive (just like many other features of Rust).</p> +<p>But that isn&rsquo;t the only way to use pattern matching. While branching is one of its core features (in that sense, pattern matching is just like git), +it doesn&rsquo;t always have to be used. Another major advantage of pattern matching lies in the ability to <em>exhaustively</em> (not be be confused with exhausting, like writing down brilliant ideas like this) match over inputs.</p> +<p>Let&rsquo;s look at the following example. Here, we have a struct representing a struct in a programming language. It has a name and fields. +We then manually implement a custom hash trait for it because we are important and need a custom hash trait. We could have written a derive macro, but didn&rsquo;t because +we don&rsquo;t understand how proc macros work.</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Struct</span> { +</span></span><span style="display:flex;"><span> name: String, +</span></span><span style="display:flex;"><span> fields: Vec<span style="color:#f92672">&lt;</span>Field<span style="color:#f92672">&gt;</span>, +</span></span><span style="display:flex;"><span>} +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span><span style="color:#66d9ef">impl</span> HandRolledHash <span style="color:#66d9ef">for</span> Struct { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">fn</span> <span style="color:#a6e22e">hash</span>(<span style="color:#f92672">&amp;</span>self, hasher: <span style="color:#66d9ef">&amp;</span><span style="color:#a6e22e">mut</span> HandRolledHasher) { +</span></span><span style="display:flex;"><span> hasher.hash(<span style="color:#f92672">&amp;</span>self.name); +</span></span><span style="display:flex;"><span> hasher.hash(<span style="color:#f92672">&amp;</span>self.fields); +</span></span><span style="display:flex;"><span> } +</span></span><span style="display:flex;"><span>} +</span></span></code></pre></div><p>This works perfectly. But then later, <a href="https://github.com/rust-lang/rustup/pull/1642">we add privacy to the language</a>. Now, all types have a visibility.</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-diff" data-lang="diff"><span style="display:flex;"><span>struct Struct { +</span></span><span style="display:flex;"><span><span style="color:#a6e22e">+ visibility: Vis, +</span></span></span><span style="display:flex;"><span><span style="color:#a6e22e"></span> name: String, +</span></span><span style="display:flex;"><span> fields: Vec&lt;Field&gt;, +</span></span><span style="display:flex;"><span>} +</span></span></code></pre></div><p>Pretty cool. Now no one can access the implementation details and make everything a mess. But wait - we have just made a mess! We didn&rsquo;t hash the visibility! +Hashing something incorrectly <a href="https://github.com/rust-lang/rust/issues/84970">doesn&rsquo;t sound too bad</a>, but it would be nice if this was prevented.</p> +<p>Thanks to exhaustive pattern matching, it would have been easy to prevent. We just change our hash implementation:</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">impl</span> HandRolledHash <span style="color:#66d9ef">for</span> Struct { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">fn</span> <span style="color:#a6e22e">hash</span>(<span style="color:#f92672">&amp;</span>self, hasher: <span style="color:#66d9ef">&amp;</span><span style="color:#a6e22e">mut</span> HandRolledHasher) { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">let</span> Self { name, fields } <span style="color:#f92672">=</span> self; +</span></span><span style="display:flex;"><span> hasher.hash(name); +</span></span><span style="display:flex;"><span> hasher.hash(fields); +</span></span><span style="display:flex;"><span> } +</span></span><span style="display:flex;"><span>} +</span></span></code></pre></div><p>And with this, adding the visibility will cause a compiler error and alert us that we need to handle it in hashing. +(The decision whether we actually do want to handle it is still up to us. We could also just turn off the computer and make new friends outside.)</p> +<p>We can conclude that pattern matching is a great feature.</p> +<h1 id="limitations-of-pattern-matching">Limitations of pattern matching</h1> +<p>But there is one big limitation of pattern matching - all of its occurrences (<code>match</code>, <code>if let</code>, <code>if let</code> chains, <code>while let</code>, <code>while let</code> chains, <code>for</code>, <code>let</code>, <code>let else</code>, and function parameters +(we do have a lot of pattern matching)) are inside of bodies, mostly as part of expressions or statements.</p> +<p>This doesn&rsquo;t sound too bad. This is where the executed code resides. But it comes at a cost of consistency. We often add many syntactical niceties to expressions and statements, but forget about items.</p> +<h1 id="items-and-sadness">Items and sadness</h1> +<p>Items have a hard life. They are the parents of everything important. <code>struct</code>, <code>enum</code>, <code>const</code>, <code>mod</code>, <code>fn</code>, <code>union</code>, <code>global_asm</code> are all things we use daily, yet their grammar is very limited. (&ldquo;free the items&rdquo; was an alternative blog post title, although &ldquo;freeing&rdquo; generally remains a concern of <a href="https://nilstrieb.github.io/nilstrieb-c-style-guide-edition-2/">my C style guide</a>).</p> +<p>For example, see the following code where we declare a few constants.</p> +<pre tabindex="0"><code>const ONE: u8 = 1; +const TWO: u8 = 1; +const THREE: u8 = 3; +</code></pre><p>There is nothing obviously wrong with this code. You understand it, I understand it, an ALGOL 68 developer from 1970 would probably understand it +and even an ancient greek philosopher might have a clue (which is impressive, given that they are all not alive anymore). But this is the kind of code that pages you at 4 AM.</p> +<p>You&rsquo;ve read the last paragraph in confusion. Of course there&rsquo;s something wrong with this code! <code>TWO</code> is <code>1</code>, yet the name strongly suggests that it should be <code>2</code>. And you&rsquo;d +be right, this was just a check to make sure you&rsquo;re still here. You are very clever and deserve this post. If you didn&rsquo;t notice it, go to sleep. It&rsquo;s good for your health.</p> +<p>But even if it was <code>2</code>, this code is still not good. There is way too much duplication! <code>const</code> is mentioned three times. This is a major distraction to the reader.</p> +<p>Let&rsquo;s have a harder example:</p> +<pre tabindex="0"><code>const ONE: u8 = 0; const +NAME: &amp; +str = &#34;nils&#34;; +const X: &amp;str += &#34;const&#34;;const A: () = (); +</code></pre><p>Here, the <code>const</code> being noise is a lot more obvious. Did you see that <code>X</code> contains <code>&quot;const&quot;</code>? Maybe you did, maybe you didn&rsquo;t. When I tested it, 0/0 people could see it.</p> +<p>Now imagine if it looked like this:</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">const</span> (<span style="color:#66d9ef">ONE</span>, <span style="color:#66d9ef">NAME</span>, X, A): (<span style="color:#66d9ef">u8</span>, <span style="color:#f92672">&amp;</span><span style="color:#66d9ef">str</span>, <span style="color:#f92672">&amp;</span><span style="color:#66d9ef">str</span>, ()) <span style="color:#f92672">=</span> (<span style="color:#ae81ff">0</span>, <span style="color:#e6db74">&#34;nils&#34;</span>, <span style="color:#e6db74">&#34;const&#34;</span>, ()); +</span></span></code></pre></div><p>Everything is way shorter and more readable.</p> +<p>What you&rsquo;ve just seen is a limited form of pattern matching!</p> +<h1 id="lets-go-further">Let&rsquo;s go further</h1> +<p>The idea of generalizing pattern matching is very powerful. We can apply this to more than just consts.</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> (Person, Car) <span style="color:#f92672">=</span> ({ name: String }, { wheels: <span style="color:#66d9ef">u8</span> }); +</span></span></code></pre></div><p>Here, we create two structs with just a single <code>struct</code> keyword. This makes it way simpler and easier to read when related structs are declared. +So far we&rsquo;ve just used tuples. But we can go even further. Structs of structs!</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Household</span><span style="color:#f92672">&lt;</span>T, U<span style="color:#f92672">&gt;</span> { +</span></span><span style="display:flex;"><span> parent: <span style="color:#a6e22e">T</span>, +</span></span><span style="display:flex;"><span> child: <span style="color:#a6e22e">U</span>, +</span></span><span style="display:flex;"><span>} +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Household</span> { parent: <span style="color:#a6e22e">Ferris</span>, child: <span style="color:#a6e22e">Corro</span> } <span style="color:#f92672">=</span> Household { +</span></span><span style="display:flex;"><span> parent: { name: String }, +</span></span><span style="display:flex;"><span> child: { name: String, unsafety: <span style="color:#66d9ef">bool</span> }, +</span></span><span style="display:flex;"><span>}; +</span></span></code></pre></div><p>Now we can nicely match on the <code>Household</code> struct containing the definition of the <code>Ferris</code> and <code>Corro</code> structs. This is equivalent to the following code:</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Feris</span> { +</span></span><span style="display:flex;"><span> name: String, +</span></span><span style="display:flex;"><span>} +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Corro</span> { +</span></span><span style="display:flex;"><span> name: String, +</span></span><span style="display:flex;"><span> unsafety: <span style="color:#66d9ef">bool</span>, +</span></span><span style="display:flex;"><span>} +</span></span></code></pre></div><p>This is already really neat, but there&rsquo;s more. We also have to consider the falliblity of patterns.</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">static</span> Some(A) <span style="color:#f92672">=</span> None; +</span></span></code></pre></div><p>This pattern doesn&rsquo;t match. Inside bodies, we could use an <code>if let</code>:</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">if</span> <span style="color:#66d9ef">let</span> Some(a) <span style="color:#f92672">=</span> None {} <span style="color:#66d9ef">else</span> {} +</span></span></code></pre></div><p>We can also apply this to items.</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">if</span> <span style="color:#66d9ef">struct</span> Some(A) <span style="color:#f92672">=</span> None { +</span></span><span style="display:flex;"><span> <span style="color:#75715e">/* other items where A exists */</span> +</span></span><span style="display:flex;"><span>} <span style="color:#66d9ef">else</span> { +</span></span><span style="display:flex;"><span> <span style="color:#75715e">/* other items where A doesn&#39;t exist */</span> +</span></span><span style="display:flex;"><span>} +</span></span></code></pre></div><p>This doesn&rsquo;t sound too useful, but it allows for extreme flexibility!</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span>macro_rules<span style="color:#f92672">!</span> are_same_type { +</span></span><span style="display:flex;"><span> (<span style="color:#75715e">$a</span>:<span style="color:#a6e22e">ty</span>, <span style="color:#75715e">$b</span>:<span style="color:#a6e22e">ty</span>) <span style="color:#f92672">=&gt;</span> {{ +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">static</span> <span style="color:#66d9ef">mut</span> <span style="color:#66d9ef">ARE_SAME</span>: <span style="color:#66d9ef">bool</span> <span style="color:#f92672">=</span> <span style="color:#66d9ef">false</span>; +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">if</span> <span style="color:#66d9ef">struct</span> <span style="color:#75715e">$a</span> <span style="color:#f92672">=</span> <span style="color:#75715e">$b</span> { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">const</span> _: () <span style="color:#f92672">=</span> <span style="color:#66d9ef">unsafe</span> { <span style="color:#66d9ef">ARE_SAME</span> <span style="color:#f92672">=</span> <span style="color:#66d9ef">true</span>; }; +</span></span><span style="display:flex;"><span> } +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">unsafe</span> { <span style="color:#66d9ef">ARE_SAME</span> } +</span></span><span style="display:flex;"><span> }}; +</span></span><span style="display:flex;"><span>} +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span><span style="color:#66d9ef">fn</span> <span style="color:#a6e22e">main</span>() { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">if</span> are_same_type!(Vec<span style="color:#f92672">&lt;</span>String<span style="color:#f92672">&gt;</span>, String) { +</span></span><span style="display:flex;"><span> println!(<span style="color:#e6db74">&#34;impossible to reach!&#34;</span>); +</span></span><span style="display:flex;"><span> } +</span></span><span style="display:flex;"><span>} +</span></span></code></pre></div><p>Ignoring this suspicious assignment to a <code>static mut</code>, this is lovely!</p> +<p>We can go further.</p> +<p>Today, items are just there with no ordering. What if we imposed an ordering? (and just like this, the C11 atomic model was born.) What if &ldquo;Rust items&rdquo; was a meta scripting language?</p> +<p>We can write a simple guessing game!</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">fn</span> input() -&gt; <span style="color:#66d9ef">u8</span> { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">const</span> <span style="color:#66d9ef">INPUT</span>: <span style="color:#66d9ef">&amp;</span><span style="color:#66d9ef">str</span> <span style="color:#f92672">=</span> prompt!(); +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">const</span> Ok(<span style="color:#66d9ef">INPUT</span>): Result<span style="color:#f92672">&lt;</span><span style="color:#66d9ef">u8</span>, ParseIntErr<span style="color:#f92672">&gt;</span> <span style="color:#f92672">=</span> <span style="color:#66d9ef">INPUT</span>.parse() <span style="color:#66d9ef">else</span> { +</span></span><span style="display:flex;"><span> compile_error!(<span style="color:#e6db74">&#34;Invalid input&#34;</span>); +</span></span><span style="display:flex;"><span> }; +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">INPUT</span> +</span></span><span style="display:flex;"><span>} +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span><span style="color:#66d9ef">const</span> <span style="color:#66d9ef">RANDOM</span>: <span style="color:#66d9ef">u8</span> <span style="color:#f92672">=</span> env!(<span style="color:#e6db74">&#34;RANDOM&#34;</span>); +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span><span style="color:#66d9ef">loop</span> { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">const</span> <span style="color:#66d9ef">INPUT</span> <span style="color:#f92672">=</span> input(); +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">if</span> <span style="color:#66d9ef">INPUT</span> <span style="color:#f92672">==</span> <span style="color:#66d9ef">RANDOM</span> { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">break</span>; <span style="color:#75715e">// continue compilation +</span></span></span><span style="display:flex;"><span><span style="color:#75715e"></span> } <span style="color:#66d9ef">else</span> <span style="color:#66d9ef">if</span> <span style="color:#66d9ef">INPUT</span> <span style="color:#f92672">&lt;</span> <span style="color:#66d9ef">RANDOM</span> { +</span></span><span style="display:flex;"><span> compile_warn!(<span style="color:#e6db74">&#34;input is smaller&#34;</span>); +</span></span><span style="display:flex;"><span> } <span style="color:#66d9ef">else</span> { +</span></span><span style="display:flex;"><span> compile_warn!(<span style="color:#e6db74">&#34;input is bigger&#34;</span>); +</span></span><span style="display:flex;"><span> } +</span></span><span style="display:flex;"><span>} +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span><span style="color:#66d9ef">fn</span> <span style="color:#a6e22e">main</span>() { +</span></span><span style="display:flex;"><span> <span style="color:#75715e">// Empty. I am useless. I strike! +</span></span></span><span style="display:flex;"><span><span style="color:#75715e"></span>} +</span></span></code></pre></div><p>If it weren&rsquo;t for <code>fn main</code> starting a strike and stopping compilation, this would have worked! Quite bold of <code>fn main</code> to just start a strike, even though there&rsquo;s no <code>union</code> in the entire program. But we really need it, it&rsquo;s not a disposable worker.</p> +<p>And then, last and least I want to highlight one of my favourite consequences of this: <code>struct else</code></p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> Some(Test) <span style="color:#f92672">=</span> None <span style="color:#66d9ef">else</span> { +</span></span><span style="display:flex;"><span> compile_error!(<span style="color:#e6db74">&#34;didn&#39;t match pattern&#34;</span>); +</span></span><span style="display:flex;"><span>}; +</span></span></code></pre></div><p><!-- raw HTML omitted -->you&rsquo;re asking yourself what you just read. meanwhile, i am asking myself what i just wrote. we are very similar.<!-- raw HTML omitted --></p>Box Is a Unique Type/posts/box-is-a-unique-type/Sat, 23 Jul 2022 00:00:00 +0000/posts/box-is-a-unique-type/We have all used Box&lt;T&gt; before in our Rust code. It&rsquo;s a glorious type, with great ergonomics and flexibility. We can use it to put our values on the heap, but it can do even more than that! struct Fields { a: String, b: String, } let fields = Box::new(Fields { a: &#34;a&#34;.to_string(), b: &#34;b&#34;.to_string() }); let a = fields.a; let b = fields.b; This kind of partial deref move is just one of the spectacular magic tricks box has up its sleeve, and they exist for good reason: They are very useful.<p>We have all used <code>Box&lt;T&gt;</code> before in our Rust code. It&rsquo;s a glorious type, with great ergonomics and flexibility. We can use it to put our values on the heap, but it can do even more than that!</p> diff --git a/posts/box-is-a-unique-type/index.html b/posts/box-is-a-unique-type/index.html index 3cf62de..a8cf790 100644 --- a/posts/box-is-a-unique-type/index.html +++ b/posts/box-is-a-unique-type/index.html @@ -131,6 +131,7 @@ are very strong, and still giving code an option to obtain these seems useful. O &'static mut T that is unleaked for drop, but the semantics of this are still unclear. If that is not possible, exposing std::ptr::Unique (with it getting boxes aliasing semantics) could be desirable. For this, all existing usages of Unique inside the standard library would have to be removed. We could also offer a std::boxed::UniqueBox that keeps the current semantics, but this would also bring direct aliasing -decisions more towards safe code, which I am not a huge fan of. Ownership is enough already.

I guess what I am wishing for are some good and flexible raw pointer types. But that’s still in the stars…

For more information about this topic, see https://github.com/rust-lang/unsafe-code-guidelines/issues/326

Thanks to the nice people on the Rust Community Discord for their feedback on the draft of this post!

\ No newline at end of file diff --git a/posts/index.html b/posts/index.html index 9441040..10a4c23 100644 --- a/posts/index.html +++ b/posts/index.html @@ -1,4 +1,6 @@ -Posts :: nilstriebs blog

Box Is a Unique Type

2022-07-23 +Posts :: nilstriebs blog

Item Patterns And Struct Else

2023-03-17 +:: Nilstrieb
#rust  +#language-design 
Bringing more expressiveness to our items

Box Is a Unique Type

2022-07-23 :: Nilstrieb
#rust  #unsafe code 
About better aliasing semantics for Box<T>
© 2023 Powered by Hugo :: Theme made by panr
diff --git a/posts/index.xml b/posts/index.xml index b82e62d..8d37c15 100644 --- a/posts/index.xml +++ b/posts/index.xml @@ -1,4 +1,167 @@ -Posts on nilstriebs blog/posts/Recent content in Posts on nilstriebs blogHugo -- gohugo.ioen-usSat, 23 Jul 2022 00:00:00 +0000Box Is a Unique Type/posts/box-is-a-unique-type/Sat, 23 Jul 2022 00:00:00 +0000/posts/box-is-a-unique-type/We have all used Box&lt;T&gt; before in our Rust code. It&rsquo;s a glorious type, with great ergonomics and flexibility. We can use it to put our values on the heap, but it can do even more than that! +Posts on nilstriebs blog/posts/Recent content in Posts on nilstriebs blogHugo -- gohugo.ioen-usFri, 17 Mar 2023 00:00:00 +0000Item Patterns And Struct Else/posts/item-patterns-and-struct-else/Fri, 17 Mar 2023 00:00:00 +0000/posts/item-patterns-and-struct-else/Pattern matching One of my favourite features of Rust is pattern matching. It&rsquo;s a simple and elegant way to deal with not just structs, but also enums! +enum ItemKind { Struct(String, Vec&lt;Field&gt;), Function(String, Body), } impl ItemKind { fn name(&amp;self) -&gt; &amp;str { match self { Self::Struct(name, _) =&gt; name, Self::Function(name, _) =&gt; name, } } } Here, we have an enum and a function to get the name out of this.<h1 id="pattern-matching">Pattern matching</h1> +<p>One of my favourite features of Rust is pattern matching. It&rsquo;s a simple and elegant way to deal with not just structs, but also enums!</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">enum</span> <span style="color:#a6e22e">ItemKind</span> { +</span></span><span style="display:flex;"><span> Struct(String, Vec<span style="color:#f92672">&lt;</span>Field<span style="color:#f92672">&gt;</span>), +</span></span><span style="display:flex;"><span> Function(String, Body), +</span></span><span style="display:flex;"><span>} +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span><span style="color:#66d9ef">impl</span> ItemKind { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">fn</span> <span style="color:#a6e22e">name</span>(<span style="color:#f92672">&amp;</span>self) -&gt; <span style="color:#66d9ef">&amp;</span><span style="color:#66d9ef">str</span> { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">match</span> self { +</span></span><span style="display:flex;"><span> Self::Struct(name, _) <span style="color:#f92672">=&gt;</span> name, +</span></span><span style="display:flex;"><span> Self::Function(name, _) <span style="color:#f92672">=&gt;</span> name, +</span></span><span style="display:flex;"><span> } +</span></span><span style="display:flex;"><span> } +</span></span><span style="display:flex;"><span>} +</span></span></code></pre></div><p>Here, we have an enum and a function to get the name out of this. In C, this would be very unsafe, as we cannot be guaranteed that our union has the right tag. +But in Rust, the compiler nicely checks it all for us. It&rsquo;s safe and expressive (just like many other features of Rust).</p> +<p>But that isn&rsquo;t the only way to use pattern matching. While branching is one of its core features (in that sense, pattern matching is just like git), +it doesn&rsquo;t always have to be used. Another major advantage of pattern matching lies in the ability to <em>exhaustively</em> (not be be confused with exhausting, like writing down brilliant ideas like this) match over inputs.</p> +<p>Let&rsquo;s look at the following example. Here, we have a struct representing a struct in a programming language. It has a name and fields. +We then manually implement a custom hash trait for it because we are important and need a custom hash trait. We could have written a derive macro, but didn&rsquo;t because +we don&rsquo;t understand how proc macros work.</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Struct</span> { +</span></span><span style="display:flex;"><span> name: String, +</span></span><span style="display:flex;"><span> fields: Vec<span style="color:#f92672">&lt;</span>Field<span style="color:#f92672">&gt;</span>, +</span></span><span style="display:flex;"><span>} +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span><span style="color:#66d9ef">impl</span> HandRolledHash <span style="color:#66d9ef">for</span> Struct { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">fn</span> <span style="color:#a6e22e">hash</span>(<span style="color:#f92672">&amp;</span>self, hasher: <span style="color:#66d9ef">&amp;</span><span style="color:#a6e22e">mut</span> HandRolledHasher) { +</span></span><span style="display:flex;"><span> hasher.hash(<span style="color:#f92672">&amp;</span>self.name); +</span></span><span style="display:flex;"><span> hasher.hash(<span style="color:#f92672">&amp;</span>self.fields); +</span></span><span style="display:flex;"><span> } +</span></span><span style="display:flex;"><span>} +</span></span></code></pre></div><p>This works perfectly. But then later, <a href="https://github.com/rust-lang/rustup/pull/1642">we add privacy to the language</a>. Now, all types have a visibility.</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-diff" data-lang="diff"><span style="display:flex;"><span>struct Struct { +</span></span><span style="display:flex;"><span><span style="color:#a6e22e">+ visibility: Vis, +</span></span></span><span style="display:flex;"><span><span style="color:#a6e22e"></span> name: String, +</span></span><span style="display:flex;"><span> fields: Vec&lt;Field&gt;, +</span></span><span style="display:flex;"><span>} +</span></span></code></pre></div><p>Pretty cool. Now no one can access the implementation details and make everything a mess. But wait - we have just made a mess! We didn&rsquo;t hash the visibility! +Hashing something incorrectly <a href="https://github.com/rust-lang/rust/issues/84970">doesn&rsquo;t sound too bad</a>, but it would be nice if this was prevented.</p> +<p>Thanks to exhaustive pattern matching, it would have been easy to prevent. We just change our hash implementation:</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">impl</span> HandRolledHash <span style="color:#66d9ef">for</span> Struct { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">fn</span> <span style="color:#a6e22e">hash</span>(<span style="color:#f92672">&amp;</span>self, hasher: <span style="color:#66d9ef">&amp;</span><span style="color:#a6e22e">mut</span> HandRolledHasher) { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">let</span> Self { name, fields } <span style="color:#f92672">=</span> self; +</span></span><span style="display:flex;"><span> hasher.hash(name); +</span></span><span style="display:flex;"><span> hasher.hash(fields); +</span></span><span style="display:flex;"><span> } +</span></span><span style="display:flex;"><span>} +</span></span></code></pre></div><p>And with this, adding the visibility will cause a compiler error and alert us that we need to handle it in hashing. +(The decision whether we actually do want to handle it is still up to us. We could also just turn off the computer and make new friends outside.)</p> +<p>We can conclude that pattern matching is a great feature.</p> +<h1 id="limitations-of-pattern-matching">Limitations of pattern matching</h1> +<p>But there is one big limitation of pattern matching - all of its occurrences (<code>match</code>, <code>if let</code>, <code>if let</code> chains, <code>while let</code>, <code>while let</code> chains, <code>for</code>, <code>let</code>, <code>let else</code>, and function parameters +(we do have a lot of pattern matching)) are inside of bodies, mostly as part of expressions or statements.</p> +<p>This doesn&rsquo;t sound too bad. This is where the executed code resides. But it comes at a cost of consistency. We often add many syntactical niceties to expressions and statements, but forget about items.</p> +<h1 id="items-and-sadness">Items and sadness</h1> +<p>Items have a hard life. They are the parents of everything important. <code>struct</code>, <code>enum</code>, <code>const</code>, <code>mod</code>, <code>fn</code>, <code>union</code>, <code>global_asm</code> are all things we use daily, yet their grammar is very limited. (&ldquo;free the items&rdquo; was an alternative blog post title, although &ldquo;freeing&rdquo; generally remains a concern of <a href="https://nilstrieb.github.io/nilstrieb-c-style-guide-edition-2/">my C style guide</a>).</p> +<p>For example, see the following code where we declare a few constants.</p> +<pre tabindex="0"><code>const ONE: u8 = 1; +const TWO: u8 = 1; +const THREE: u8 = 3; +</code></pre><p>There is nothing obviously wrong with this code. You understand it, I understand it, an ALGOL 68 developer from 1970 would probably understand it +and even an ancient greek philosopher might have a clue (which is impressive, given that they are all not alive anymore). But this is the kind of code that pages you at 4 AM.</p> +<p>You&rsquo;ve read the last paragraph in confusion. Of course there&rsquo;s something wrong with this code! <code>TWO</code> is <code>1</code>, yet the name strongly suggests that it should be <code>2</code>. And you&rsquo;d +be right, this was just a check to make sure you&rsquo;re still here. You are very clever and deserve this post. If you didn&rsquo;t notice it, go to sleep. It&rsquo;s good for your health.</p> +<p>But even if it was <code>2</code>, this code is still not good. There is way too much duplication! <code>const</code> is mentioned three times. This is a major distraction to the reader.</p> +<p>Let&rsquo;s have a harder example:</p> +<pre tabindex="0"><code>const ONE: u8 = 0; const +NAME: &amp; +str = &#34;nils&#34;; +const X: &amp;str += &#34;const&#34;;const A: () = (); +</code></pre><p>Here, the <code>const</code> being noise is a lot more obvious. Did you see that <code>X</code> contains <code>&quot;const&quot;</code>? Maybe you did, maybe you didn&rsquo;t. When I tested it, 0/0 people could see it.</p> +<p>Now imagine if it looked like this:</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">const</span> (<span style="color:#66d9ef">ONE</span>, <span style="color:#66d9ef">NAME</span>, X, A): (<span style="color:#66d9ef">u8</span>, <span style="color:#f92672">&amp;</span><span style="color:#66d9ef">str</span>, <span style="color:#f92672">&amp;</span><span style="color:#66d9ef">str</span>, ()) <span style="color:#f92672">=</span> (<span style="color:#ae81ff">0</span>, <span style="color:#e6db74">&#34;nils&#34;</span>, <span style="color:#e6db74">&#34;const&#34;</span>, ()); +</span></span></code></pre></div><p>Everything is way shorter and more readable.</p> +<p>What you&rsquo;ve just seen is a limited form of pattern matching!</p> +<h1 id="lets-go-further">Let&rsquo;s go further</h1> +<p>The idea of generalizing pattern matching is very powerful. We can apply this to more than just consts.</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> (Person, Car) <span style="color:#f92672">=</span> ({ name: String }, { wheels: <span style="color:#66d9ef">u8</span> }); +</span></span></code></pre></div><p>Here, we create two structs with just a single <code>struct</code> keyword. This makes it way simpler and easier to read when related structs are declared. +So far we&rsquo;ve just used tuples. But we can go even further. Structs of structs!</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Household</span><span style="color:#f92672">&lt;</span>T, U<span style="color:#f92672">&gt;</span> { +</span></span><span style="display:flex;"><span> parent: <span style="color:#a6e22e">T</span>, +</span></span><span style="display:flex;"><span> child: <span style="color:#a6e22e">U</span>, +</span></span><span style="display:flex;"><span>} +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Household</span> { parent: <span style="color:#a6e22e">Ferris</span>, child: <span style="color:#a6e22e">Corro</span> } <span style="color:#f92672">=</span> Household { +</span></span><span style="display:flex;"><span> parent: { name: String }, +</span></span><span style="display:flex;"><span> child: { name: String, unsafety: <span style="color:#66d9ef">bool</span> }, +</span></span><span style="display:flex;"><span>}; +</span></span></code></pre></div><p>Now we can nicely match on the <code>Household</code> struct containing the definition of the <code>Ferris</code> and <code>Corro</code> structs. This is equivalent to the following code:</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Feris</span> { +</span></span><span style="display:flex;"><span> name: String, +</span></span><span style="display:flex;"><span>} +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Corro</span> { +</span></span><span style="display:flex;"><span> name: String, +</span></span><span style="display:flex;"><span> unsafety: <span style="color:#66d9ef">bool</span>, +</span></span><span style="display:flex;"><span>} +</span></span></code></pre></div><p>This is already really neat, but there&rsquo;s more. We also have to consider the falliblity of patterns.</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">static</span> Some(A) <span style="color:#f92672">=</span> None; +</span></span></code></pre></div><p>This pattern doesn&rsquo;t match. Inside bodies, we could use an <code>if let</code>:</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">if</span> <span style="color:#66d9ef">let</span> Some(a) <span style="color:#f92672">=</span> None {} <span style="color:#66d9ef">else</span> {} +</span></span></code></pre></div><p>We can also apply this to items.</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">if</span> <span style="color:#66d9ef">struct</span> Some(A) <span style="color:#f92672">=</span> None { +</span></span><span style="display:flex;"><span> <span style="color:#75715e">/* other items where A exists */</span> +</span></span><span style="display:flex;"><span>} <span style="color:#66d9ef">else</span> { +</span></span><span style="display:flex;"><span> <span style="color:#75715e">/* other items where A doesn&#39;t exist */</span> +</span></span><span style="display:flex;"><span>} +</span></span></code></pre></div><p>This doesn&rsquo;t sound too useful, but it allows for extreme flexibility!</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span>macro_rules<span style="color:#f92672">!</span> are_same_type { +</span></span><span style="display:flex;"><span> (<span style="color:#75715e">$a</span>:<span style="color:#a6e22e">ty</span>, <span style="color:#75715e">$b</span>:<span style="color:#a6e22e">ty</span>) <span style="color:#f92672">=&gt;</span> {{ +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">static</span> <span style="color:#66d9ef">mut</span> <span style="color:#66d9ef">ARE_SAME</span>: <span style="color:#66d9ef">bool</span> <span style="color:#f92672">=</span> <span style="color:#66d9ef">false</span>; +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">if</span> <span style="color:#66d9ef">struct</span> <span style="color:#75715e">$a</span> <span style="color:#f92672">=</span> <span style="color:#75715e">$b</span> { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">const</span> _: () <span style="color:#f92672">=</span> <span style="color:#66d9ef">unsafe</span> { <span style="color:#66d9ef">ARE_SAME</span> <span style="color:#f92672">=</span> <span style="color:#66d9ef">true</span>; }; +</span></span><span style="display:flex;"><span> } +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">unsafe</span> { <span style="color:#66d9ef">ARE_SAME</span> } +</span></span><span style="display:flex;"><span> }}; +</span></span><span style="display:flex;"><span>} +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span><span style="color:#66d9ef">fn</span> <span style="color:#a6e22e">main</span>() { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">if</span> are_same_type!(Vec<span style="color:#f92672">&lt;</span>String<span style="color:#f92672">&gt;</span>, String) { +</span></span><span style="display:flex;"><span> println!(<span style="color:#e6db74">&#34;impossible to reach!&#34;</span>); +</span></span><span style="display:flex;"><span> } +</span></span><span style="display:flex;"><span>} +</span></span></code></pre></div><p>Ignoring this suspicious assignment to a <code>static mut</code>, this is lovely!</p> +<p>We can go further.</p> +<p>Today, items are just there with no ordering. What if we imposed an ordering? (and just like this, the C11 atomic model was born.) What if &ldquo;Rust items&rdquo; was a meta scripting language?</p> +<p>We can write a simple guessing game!</p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">fn</span> input() -&gt; <span style="color:#66d9ef">u8</span> { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">const</span> <span style="color:#66d9ef">INPUT</span>: <span style="color:#66d9ef">&amp;</span><span style="color:#66d9ef">str</span> <span style="color:#f92672">=</span> prompt!(); +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">const</span> Ok(<span style="color:#66d9ef">INPUT</span>): Result<span style="color:#f92672">&lt;</span><span style="color:#66d9ef">u8</span>, ParseIntErr<span style="color:#f92672">&gt;</span> <span style="color:#f92672">=</span> <span style="color:#66d9ef">INPUT</span>.parse() <span style="color:#66d9ef">else</span> { +</span></span><span style="display:flex;"><span> compile_error!(<span style="color:#e6db74">&#34;Invalid input&#34;</span>); +</span></span><span style="display:flex;"><span> }; +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">INPUT</span> +</span></span><span style="display:flex;"><span>} +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span><span style="color:#66d9ef">const</span> <span style="color:#66d9ef">RANDOM</span>: <span style="color:#66d9ef">u8</span> <span style="color:#f92672">=</span> env!(<span style="color:#e6db74">&#34;RANDOM&#34;</span>); +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span><span style="color:#66d9ef">loop</span> { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">const</span> <span style="color:#66d9ef">INPUT</span> <span style="color:#f92672">=</span> input(); +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">if</span> <span style="color:#66d9ef">INPUT</span> <span style="color:#f92672">==</span> <span style="color:#66d9ef">RANDOM</span> { +</span></span><span style="display:flex;"><span> <span style="color:#66d9ef">break</span>; <span style="color:#75715e">// continue compilation +</span></span></span><span style="display:flex;"><span><span style="color:#75715e"></span> } <span style="color:#66d9ef">else</span> <span style="color:#66d9ef">if</span> <span style="color:#66d9ef">INPUT</span> <span style="color:#f92672">&lt;</span> <span style="color:#66d9ef">RANDOM</span> { +</span></span><span style="display:flex;"><span> compile_warn!(<span style="color:#e6db74">&#34;input is smaller&#34;</span>); +</span></span><span style="display:flex;"><span> } <span style="color:#66d9ef">else</span> { +</span></span><span style="display:flex;"><span> compile_warn!(<span style="color:#e6db74">&#34;input is bigger&#34;</span>); +</span></span><span style="display:flex;"><span> } +</span></span><span style="display:flex;"><span>} +</span></span><span style="display:flex;"><span> +</span></span><span style="display:flex;"><span><span style="color:#66d9ef">fn</span> <span style="color:#a6e22e">main</span>() { +</span></span><span style="display:flex;"><span> <span style="color:#75715e">// Empty. I am useless. I strike! +</span></span></span><span style="display:flex;"><span><span style="color:#75715e"></span>} +</span></span></code></pre></div><p>If it weren&rsquo;t for <code>fn main</code> starting a strike and stopping compilation, this would have worked! Quite bold of <code>fn main</code> to just start a strike, even though there&rsquo;s no <code>union</code> in the entire program. But we really need it, it&rsquo;s not a disposable worker.</p> +<p>And then, last and least I want to highlight one of my favourite consequences of this: <code>struct else</code></p> +<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-rust" data-lang="rust"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> Some(Test) <span style="color:#f92672">=</span> None <span style="color:#66d9ef">else</span> { +</span></span><span style="display:flex;"><span> compile_error!(<span style="color:#e6db74">&#34;didn&#39;t match pattern&#34;</span>); +</span></span><span style="display:flex;"><span>}; +</span></span></code></pre></div><p><!-- raw HTML omitted -->you&rsquo;re asking yourself what you just read. meanwhile, i am asking myself what i just wrote. we are very similar.<!-- raw HTML omitted --></p>Box Is a Unique Type/posts/box-is-a-unique-type/Sat, 23 Jul 2022 00:00:00 +0000/posts/box-is-a-unique-type/We have all used Box&lt;T&gt; before in our Rust code. It&rsquo;s a glorious type, with great ergonomics and flexibility. We can use it to put our values on the heap, but it can do even more than that! struct Fields { a: String, b: String, } let fields = Box::new(Fields { a: &#34;a&#34;.to_string(), b: &#34;b&#34;.to_string() }); let a = fields.a; let b = fields.b; This kind of partial deref move is just one of the spectacular magic tricks box has up its sleeve, and they exist for good reason: They are very useful.<p>We have all used <code>Box&lt;T&gt;</code> before in our Rust code. It&rsquo;s a glorious type, with great ergonomics and flexibility. We can use it to put our values on the heap, but it can do even more than that!</p> diff --git a/posts/item-patterns-and-struct-else/index.html b/posts/item-patterns-and-struct-else/index.html new file mode 100644 index 0000000..49dc180 --- /dev/null +++ b/posts/item-patterns-and-struct-else/index.html @@ -0,0 +1,131 @@ +Item Patterns And Struct Else :: nilstriebs blog

Item Patterns And Struct Else

2023-03-17 +:: Nilstrieb +:: 7 min read (1351 words)
#rust  +#language-design 

Pattern matching⌗

One of my favourite features of Rust is pattern matching. It’s a simple and elegant way to deal with not just structs, but also enums!

enum ItemKind {
+  Struct(String, Vec<Field>),
+  Function(String, Body),
+}
+
+impl ItemKind {
+  fn name(&self) -> &str {
+    match self {
+      Self::Struct(name, _) => name,
+      Self::Function(name, _) => name,
+    }
+  }
+}
+

Here, we have an enum and a function to get the name out of this. In C, this would be very unsafe, as we cannot be guaranteed that our union has the right tag. +But in Rust, the compiler nicely checks it all for us. It’s safe and expressive (just like many other features of Rust).

But that isn’t the only way to use pattern matching. While branching is one of its core features (in that sense, pattern matching is just like git), +it doesn’t always have to be used. Another major advantage of pattern matching lies in the ability to exhaustively (not be be confused with exhausting, like writing down brilliant ideas like this) match over inputs.

Let’s look at the following example. Here, we have a struct representing a struct in a programming language. It has a name and fields. +We then manually implement a custom hash trait for it because we are important and need a custom hash trait. We could have written a derive macro, but didn’t because +we don’t understand how proc macros work.

struct Struct {
+  name: String,
+  fields: Vec<Field>,
+}
+
+impl HandRolledHash for Struct {
+  fn hash(&self, hasher: &mut HandRolledHasher) {
+    hasher.hash(&self.name);
+    hasher.hash(&self.fields);
+  }
+}
+

This works perfectly. But then later, we add privacy to the language. Now, all types have a visibility.

struct Struct {
++ visibility: Vis,
+  name: String,
+  fields: Vec<Field>,
+}
+

Pretty cool. Now no one can access the implementation details and make everything a mess. But wait - we have just made a mess! We didn’t hash the visibility! +Hashing something incorrectly doesn’t sound too bad, but it would be nice if this was prevented.

Thanks to exhaustive pattern matching, it would have been easy to prevent. We just change our hash implementation:

impl HandRolledHash for Struct {
+  fn hash(&self, hasher: &mut HandRolledHasher) {
+    let Self { name, fields } = self;
+    hasher.hash(name);
+    hasher.hash(fields);
+  }
+}
+

And with this, adding the visibility will cause a compiler error and alert us that we need to handle it in hashing. +(The decision whether we actually do want to handle it is still up to us. We could also just turn off the computer and make new friends outside.)

We can conclude that pattern matching is a great feature.

Limitations of pattern matching⌗

But there is one big limitation of pattern matching - all of its occurrences (match, if let, if let chains, while let, while let chains, for, let, let else, and function parameters +(we do have a lot of pattern matching)) are inside of bodies, mostly as part of expressions or statements.

This doesn’t sound too bad. This is where the executed code resides. But it comes at a cost of consistency. We often add many syntactical niceties to expressions and statements, but forget about items.

Items and sadness⌗

Items have a hard life. They are the parents of everything important. struct, enum, const, mod, fn, union, global_asm are all things we use daily, yet their grammar is very limited. (“free the items” was an alternative blog post title, although “freeing” generally remains a concern of my C style guide).

For example, see the following code where we declare a few constants.

const ONE: u8 = 1;
+const TWO: u8 = 1;
+const THREE: u8 = 3;
+

There is nothing obviously wrong with this code. You understand it, I understand it, an ALGOL 68 developer from 1970 would probably understand it +and even an ancient greek philosopher might have a clue (which is impressive, given that they are all not alive anymore). But this is the kind of code that pages you at 4 AM.

You’ve read the last paragraph in confusion. Of course there’s something wrong with this code! TWO is 1, yet the name strongly suggests that it should be 2. And you’d +be right, this was just a check to make sure you’re still here. You are very clever and deserve this post. If you didn’t notice it, go to sleep. It’s good for your health.

But even if it was 2, this code is still not good. There is way too much duplication! const is mentioned three times. This is a major distraction to the reader.

Let’s have a harder example:

const ONE: u8 = 0; const
+NAME: &
+str = "nils";
+       const X: &str
+  =   "const";const A: () = ();
+

Here, the const being noise is a lot more obvious. Did you see that X contains "const"? Maybe you did, maybe you didn’t. When I tested it, 0/0 people could see it.

Now imagine if it looked like this:

const (ONE, NAME, X, A): (u8, &str, &str, ()) = (0, "nils", "const", ());
+

Everything is way shorter and more readable.

What you’ve just seen is a limited form of pattern matching!

Let’s go further⌗

The idea of generalizing pattern matching is very powerful. We can apply this to more than just consts.

struct (Person, Car) = ({ name: String }, { wheels: u8 });
+

Here, we create two structs with just a single struct keyword. This makes it way simpler and easier to read when related structs are declared. +So far we’ve just used tuples. But we can go even further. Structs of structs!

struct Household<T, U> {
+  parent: T,
+  child: U,
+}
+
+struct Household { parent: Ferris, child: Corro } = Household {
+  parent: { name: String },
+  child: { name: String, unsafety: bool },
+};
+

Now we can nicely match on the Household struct containing the definition of the Ferris and Corro structs. This is equivalent to the following code:

struct Feris {
+  name: String,
+}
+
+struct Corro {
+  name: String,
+  unsafety: bool,
+}
+

This is already really neat, but there’s more. We also have to consider the falliblity of patterns.

static Some(A) = None;
+

This pattern doesn’t match. Inside bodies, we could use an if let:

if let Some(a) = None {} else {}
+

We can also apply this to items.

if struct Some(A) = None {
+  /* other items where A exists */
+} else {
+  /* other items where A doesn't exist */
+}
+

This doesn’t sound too useful, but it allows for extreme flexibility!

macro_rules! are_same_type {
+  ($a:ty, $b:ty) => {{
+    static mut ARE_SAME: bool = false;
+  
+    if struct $a = $b {
+      const _: () = unsafe { ARE_SAME = true; };
+    }
+    
+    unsafe { ARE_SAME }
+  }};
+}
+
+fn main() {
+  if are_same_type!(Vec<String>, String) {
+    println!("impossible to reach!");
+  }
+}
+

Ignoring this suspicious assignment to a static mut, this is lovely!

We can go further.

Today, items are just there with no ordering. What if we imposed an ordering? (and just like this, the C11 atomic model was born.) What if “Rust items” was a meta scripting language?

We can write a simple guessing game!

struct fn input() -> u8 {
+  const INPUT: &str = prompt!();
+  const Ok(INPUT): Result<u8, ParseIntErr> = INPUT.parse() else {
+    compile_error!("Invalid input");
+  };
+  INPUT
+}
+
+const RANDOM: u8 = env!("RANDOM");
+
+loop {
+  const INPUT = input();
+  if INPUT == RANDOM {
+    break; // continue compilation
+  } else if INPUT < RANDOM {
+    compile_warn!("input is smaller");
+  } else {
+    compile_warn!("input is bigger");
+  }
+}
+
+fn main() {
+  // Empty. I am useless. I strike!
+}
+

If it weren’t for fn main starting a strike and stopping compilation, this would have worked! Quite bold of fn main to just start a strike, even though there’s no union in the entire program. But we really need it, it’s not a disposable worker.

And then, last and least I want to highlight one of my favourite consequences of this: struct else

struct Some(Test) = None else {
+  compile_error!("didn't match pattern");
+};
+

you’re asking yourself what you just read. meanwhile, i am asking myself what i just wrote. we are very similar.

© 2023 Powered by Hugo +:: Theme made by panr
+
\ No newline at end of file diff --git a/sitemap.xml b/sitemap.xml index de25e85..7392509 100644 --- a/sitemap.xml +++ b/sitemap.xml @@ -1 +1 @@ -/posts/box-is-a-unique-type/2022-07-23T00:00:00+00:00/2022-07-23T00:00:00+00:00/posts/2022-07-23T00:00:00+00:00/tags/rust/2022-07-23T00:00:00+00:00/tags/2022-07-23T00:00:00+00:00/tags/unsafe-code/2022-07-23T00:00:00+00:00/categories/ \ No newline at end of file +/posts/item-patterns-and-struct-else/2023-03-17T00:00:00+00:00/tags/language-design/2023-03-17T00:00:00+00:00/2023-03-17T00:00:00+00:00/posts/2023-03-17T00:00:00+00:00/tags/rust/2023-03-17T00:00:00+00:00/tags/2023-03-17T00:00:00+00:00/posts/box-is-a-unique-type/2022-07-23T00:00:00+00:00/tags/unsafe-code/2022-07-23T00:00:00+00:00/categories/ \ No newline at end of file diff --git a/tags/index.html b/tags/index.html index 67be240..b04d8ae 100644 --- a/tags/index.html +++ b/tags/index.html @@ -1,3 +1,3 @@ -Tags :: nilstriebs blog

Tags