Rust Data Modelling Without Classes 

ERRATA - 4:12 Replace -> Replaced

I’m going through “Writing an Interpreter in Go” (Thorsten, 2018) but instead of Go I’m writing the program in Rust, translating the code as it’s presented. The Rust version using enums is *so much cleaner* then the class based system presented, and I get to skip whole sections when I realize that he’s implementing something that I already have for free. I’d highly recommend the exercise.

As a university student looking for an excuse to learn Rust, I want to thank you so much for making concepts in your videos easier to understand!

This is my favourite part of rust! As someone who works within robotics, representing state and transitions is vital, both for safety and for ensuring confidence that the system will be in well defined states for the lifetime of the program. With so many other languages, a small change in the represented state would correspond to an unknown amount of work to correct the system behaviour elsewhere, as you just don't know that it's wrong until you reach that part of the code.

Your long search for a good state machine example was certainly worth it! Not sure how you just casually looked at the super mario world manual though haha, but I'm glad you did! Thank you as always for your great content!

When I was first starting to learn Rust coming from Python I was struggling to see the benefit of enums, but then I realized you HAVE to use enums to represent certain data structures. At first that felt restrictive, but then I realized that restriction relieved so much mental burden I'd have otherwise spent in Python thinking about the structure of the program just so that I, the one writing the program, would be able to understand it. In Rust more than any other language I feel like I can just DO things, rush them even, and the compiler is like R2-D2 was to Luke Skywalker, guiding me and filling the gaps I'm unable to fully grasp in my limited human working memory. When my code does start to get unwieldy, refactoring isn't some mess where everything becomes more confusing, often as a program grows it seems little slots arise where you know a certain type (like an enum) clicks in like a puzzle piece. My two cents of advice to people who want to learn Rust coming from more OO languages: 1. ```struct != class```: Be careful with Impl block methods and the "self" keyword. Structs are purely data and methods are syntactic sugar for functions, as they always are, but this relationship is much closer to the surface in Rust than it is in other OO languages and you'll hit some frustrating roadblocks if you accept "struct == class" at face value. 2. Avoid Traits except where the compiler tells you you need them or an API requires them. (i.e. #[derive(Clone, Copy, Debug)] ). As you learn you will find places where they fill a niche, but shoehorning them in as a replacement for c++ templates/js interfaces/python protocols is a recipe for unreadable spaghetti code. 3. USE ENUMS. ALWAYS, ALWAYS, ALWAYS. They are fucking awesome, as this video handily outlines.

I love enums, they're a really nice way to represent "choices" in the type system, rather than writing ugly if statements that try to verify everything with a bunch of bools

Having learned Haskell just before Rust, enums felt just right. And since now having spent a lot more time in Rust, I always feel good when I use a nice match expression! Thanks Tris!

One of my favorite RU-vid channels even though I don’t really watch the videos. It’s just something about the overall style and personality that bleeds through them. There’s no filler and there’s no commercialism. It just feels like a sincerely enthusiastic person trying to tell you something clearly that actually is of interest. It definitely hugely has led me to be sure to check out more Rust whenever the opportunity is there. I still hear his swinging British voice in my head when I try it, like, “In Rust, all you have to do is read the compiler message carefully.”

I pretty consistently worry that I am watching your videos too soon, having barely started with Rust, and the elegance of your explanations prevents brain fog.

I've instinctively tried to use this in other languages, only to find despair. Rust is just so fantastic.

That Mario example is what I've needed for months! That's so good. And tying it to the actual code, chefs kiss. I finally get state machines, and I have a tangible idea of how it can be made. Thank you!

// personally I aim to live up to std::u8::MAX 8:27 Great motivation!!!

One of my favourite applications for state machines is fighting game input parsing. In a game like Street Fighter, a particular special move might require a sequence such as down, down-right, right, punch. But the games build in a bit of leniency, so your timing doesn't have to be exact. A great way to read the player's inputs then is to create a state machine for the special move, feeding the last several frames' worth of inputs through it. It makes it easy to define leniency as well as failure states in precise terms.

I always wonder why a lot of popular languages don't have sum types natively built in. It's like.. one of the most fundamental way to model data

Illustrating FSMs using Super Mario powerups was an unexpected twist. Great stuff!

Your videos spiked so much interest for Rust in me that I ditched the plan for learning Golang. Reading the Chapter 10 in TheBook now.

As someone who is currently learning rust, i just finished the chapter on enums from “the book”, and i was able to understand and comprehend whats going on, hats off to you for explaining a what seems like complicated topic in such an elegant way !! This was both a useful rust video and an explanation of how machine state logic works! Amazing

I don't know Rust but it's really fun pausing your videos on code snippets and compiler errors, trying to figure out what it means and being successful almost every time!

On the topic of making invalid states unrepresentable and normalized representations of data, I recommend the excellent essay by Alexis King by the title "Parse, don't validate", it's in haskell but I believe its still relevant enough. Great vid btw :)

OOP is very well suited to the original use-case that drove its adoption: modern UIs. Modeling Windows, dialog boxes, widgets as classes actually matches how we think about and interact with those objects very well. Inheritance is natural and obvious for most modern UI elements, the idea of a click "sending a message" to the object that was clicked on is super intuitive and straightforward, etc. C++ was an absolutely vital evolution of C, as Windows and MacOS became ubiquitous. If OOP is indeed the mistake that you suggest it is-- which I don't feel qualified to have an opinion about, since I last programmed professionally over a decade ago, and even then it was systems-level programming so I wasn't using OOP much-- then I feel sure it must be because programmers who used OOP principles as a hammer to great effect in the UI domain, looked at every other problem domain and saw a bunch of nails.

Great video! My one piece of advice is: this works in Rust because of its language-level features. If you’re working in an OO language (like I am for my day job) you may end up with something that is both non-idiomatic and also doesn’t provide the same guarantees as the Rust equivalent. I have been guilty of this and it does not turn out like you’ll want it to 😅 All the more reason to oxidize your codebase, though!

I really enjoy the idea of modeling states and find it far more intuitive as a developer than OOP (especially the make many classes just to inherit down to the one I actually use). I am sure we can get around this by simplifying but my mind immediately tries to explore the edge cases where it's difficult to model the states directly with a finite state machine - such as programs that might simulate complex biological systems. It certainly doesn't abrogate the utility of representation by states but it does bring into view some interesting ideas of more fluid states of giant matrices of floating point numbers.

In the 1980s and 1990s, there were many programming language designers working on OOP (also functional programming), such as Luca Cardelli, who was involved in the design and development of Modula-3 and ML, Philip Wadler also worked on Java and Haskell. We can see that the history of OOP and FP is closely related. However, due to the excellent marketing techniques of Sun and Oracle, some people later believe that Java has the sole right to explain OOP :P

This is one of the most underrated features of rust. Programming states is hard and rust makes it so easy.

Amazing video! I’m just getting into rust, coming from an OO background and this really clarified some things for me. Thanks for your work!

Hi, You have given me so many cool insights and delimited them so nicely from concepts that I knew from other languages allowing me to see what the purpose they have and what the reasoning behind them are. You have in that way contributed to how I go about my work and in turn. Thanks so much.

This is very informative. I've always struggled with data modelling, in rust, in particular. Will be saving this for many rewatchs. As always, thanks for the quality content.

Hey, i really enjoy this kind of „advanced technical rust“ would love to see more of these concepts! Thank you for your great videos!

Amazing video as always. I have kind of thought of this: I have recently had an OOP design patterns course and a functional programming course and I thought:"there must be an easier way of implementing these patterns functionally". Turns out you can indeed

The specificity in this video was excellent, I feel like I both got an idea of the theory and a concrete relatable implementation that can scale to any size. I loved this format to present the content. Well done!

I love algebraic type systems so much!! Haskell made me fall in love with them. I love this!!

Great as always! I'm currently writing my Bachelor's Thesis and I have utilised Rust for a lot of the implementation, and its growing more and more on me, thanks for introducing me to this wonderful language :)

Great video as always! Recently had to do a project that would need to be super reliable as it would fetch data constantly, and match arms to make error handling have just been great. Together with loop flags the code just looks clean is super readable

Greetings from New Zealand. Love your videos mate, just straight up the guts info to the ears. Thanks!

Nice, looking forward to learning rust - my goal for the next weeks. I'm an experienced scala developer and was happy to see lots of familiar concepts. Let's see how far I get. Thanks for your great, concise and motivational videos!

Gotta say, this is one of the first few times I've seen a truly interesting and relevant sponsor product

I love enums. They're the rust feature I find the most useful for actually representing the problems I need. In most other languages they are less strict, less useful or dont exist at all.

C++ has been learning a lot from Rust, and this kind of enum has been implemented in the Standard Template Library as std::variant. The match described here would be analogous to std::visit executes a function on the current state of the variant, and requires that the function being executed has a valid overload for any of the types declared.

Really cracking video. I'm just starting out with Rust, approaching as a full reboot of my understanding of programming. I found the video very helpful. Great example with Mario..

As soon as I tried out enums and match in rust. I completely fell in love with the language once again. And it's intuitive, everytime I use emus and match statements, it FEELS very familiar, yet, not.

awesome content as always 💯 Thank you so much 🙏🙏

I applaud you, sir. Superior presentation, as I've come to expect. :)

Very interesting way of designing a program(and thinking about the problem). Looking forward to applying the state machine!

Amazing. Every time I watch your videos it feels like one step toward being a better developer.

I know that this is a video about enum specifically, but it ended up being one of the best videos arguing for the use of rust.

Thanks for the video, I also used this trick in my games. But still busy with finding a good way to-do behaviour tree's (re-use logic) and make it so that testing the logic is easy… and with testing I mean unit testing the outcome when structuring the tree with small reusable components.

I’m building my first desktop app for my FIL’s work. For simplicity, I’m writing it in Python using a custom TUI package. The core interactivity of the app involves mapping key presses to actions, which depend on which screen is loaded. I was planning to recreate the app in Rust once I finished (Taurus framework). Now I know how I’ll approach it. Thank you!

Thank you for your video’s ❤. They definitely have me excited and high,y motivated to learn Rust.

you are a real teacher. I must say i watched a lot of rust videos but only you were able to explain what actually rust enum is.

Great videos and info! It's really clear and concise ❤ thank you! Greetings from Cuba.

This video is just amazing. Coming from python to rust would be impossible for me without this channel!

Excellent video yet again. 🎉 Thanks for making RU-vid a better place.

I was just watching your video on How to learn Rust and this drops, NOICE

Thank you so much for these videos! My first language was java and I think it really messed with me for years so I never felt like I could actually make anything. OO is all I knew, so it's all that made sense. But the last week or so learning rust, programming finally feels... natural to me instead of a frustrating byzantine experience. Though I did play with C, all the memory and boilerplate I had to make and use really scared me off, making me feel stupid.. Rust makes me feel like a genius, like you said!

this video sold me rust. Thanks NoBoilerplate

You can do something similar with phantom data types, like having a type called `Container` that can be locked or unlocked. This is useful because you can enforce state at the API level, for example you, if do `impl Container { fn open {...} }`, the open function will only be usable when the container is in the unlocked state.

Your videos are some of the most usefully educational on the internet.

I already solved this problem through having utility functions in traits. You have a function to get a smart pointer to some base stucture in a structure or the structure itself, a function to convert the smart pointer to a any, and a function to get embedded structures or the structure itself based on the logic of a passed function. You can create a list of different typed data and do everything here and more.

As a fan of Rust I have to acknowledge that Typescript's algebraic types are even more expressive. You can create union or intersection types by enumerating existing types or existing values. E.g. type result = number | boolean | "error" | (mytype & myothertype). And it also does OOP the right way, by supporting structural, as opposed to nominal subtyping (just like Rust).

Thanks!

Fascinating. As a mostly .Net user I'm a little envious about this.

I know this isn't the topic of the video but it was only a week or two ago that I was saying that I didn't understand why nonone had made a spreadsheet app that supported python in the cells. Seems so obviously brilliant

Best state machine description ever!

This is amazing. The amount of time I've had to spend working on edge case unit testing is exhausting.

quadratic is amazing, glad to see high level sponsors

Brilliant as always. Articulating perfectly my reasons for migrating to Rust

04:14 nice thing about objects is: `a.push(1)` is shorter than `push_to_array(a,1)` most other stuff is obfuscation

I am a old school DBA and data modeling scientist. Your video has convinced me to look further into the Rust language. Old dogs can learn new tricks. 😆

The Mario example is Great. This is no harder then when I did Enums in C#, except this is much better.

Hey! This is again a really great video. I get that your channel is really about showing what Rust is capable to do but I am really interested in understanding the state of rust for embedded systems. As it's stands it is generally a domain lacking great resources to learn it and I think it could greatly benefit from Rust structured way to go about things and its great community focused on creating resources for other to do great things. Would you consider making a video about that topic or could you recommend one? It's always a pleasure to see that you have uploaded a new video (or podcast)!

The cat example is a bit dark 🤣🤣🤣 Great video as always.

As always lovely video!

You can make error state unrepresentable in every good language (I often do it in Java), the reason we have so many IFs is because we are writing client facing applications that have to handle bad input, you can't make 400 Bad Request unrepresentable.

Great video! I didn't necessarily think of rust enums as being so helpful at preventing invalid states (btw, at 8:37, I think std::u8::MAX is deprecated :))

i think your channel is my new fav

This video was *awesome*, thank you! I thought the quip about tables existing long before and after OO was maybe too witty to be true and a quick google had me wanting to a “well actually…” comment. Those suck and a little more googling showed that the history of these things is murky and entirely dependent on how you chose to draw the lines. I also don’t think leaving that kind of comment even works since it’d comparing very different “types” of things; the coining of “third normal form” v. the coining of “object oriented programming”: one hasn’t changed since 1971 (3NF) and the other continues to “evolve” since the initial coining around the same time (maybe “mutate” is a better descriptor!). No matter what, your point works very well :)

world needs simple yet powerful demo examples like supermario!

That Mario example was so on point that i wonder why people don't use videogames when trying to implement automatas/state machines while learning. It's so obvious actually haha. I had to build a very abstract state machine on my automata class.

Made my day!

The only thing I'd change in the example is to make collect return a Player instead of mutating the self.state field. Of course, this depends on how the wider system behaves, but one should always default to immutability unless you have a strong reason not to.

Great video as always! Rust's enum + switch statements look really powerful, but is there a way to leverage that power if the 'states' are specified in a database (think product categories that can be specified by an admin in an ecommerce system)? I think not since all this analysis needs to happen at compile time, but I'd love to hear what you think.

Lmao I though RU-vid bugged out when I saw a meme instead of the usual style of the thumbnail

It's not exactly the same, and it's not completely there yet, but Java is working on bringing this style of programming to Java with the features: sealed classes, switch expressions, and pattern matching in switch. They call it "data oriented programming" and it's one of the over-arching goals of Project Amber - minor improvements to the language where the sum is greater than the parts.

8:39 gender: String ❤

I have a question: in the Mario example, the "match" is used against the tuple (a, b) so the compiler could cover all combinations of two enums. I understand that the state machine will never reach an undefined state, but as long as the "_" (the rest of the conditions) is used in the tuple, compile can't tell whether a wrong default condition logic is given when we add new options in to the enums, am I right?

Rust's Enums make me dread working in any other language - they're just so powerful and I wish that the equivalents in Python and TypeScript were as powerful. It's technically possible to do it in both, but Rust just makes it so nice to work with.

Sum types can be simulated in languages that don't have them using interfaces/abstract base classes, and distinct types for each variant. For example instead of a single Cat class/struct, you'd have two classes: AliveCat and DeadCat. That way you can have just the alive cat implement the IAliveCat inferface (which can get hungry) and the implementation is of course up to you. Of course both of them ca implement a base ICat (marker) interface. At the end of the day, the way to correctly model a domain in your programming language of choice is mostly a matter of skills.

What would be best practices of doing | representing layered state machines? Like how an app needs to handle network requests & responses, user input, and results from long running tasks?

fantastic video as usual! thank you. I hope one day to be as savvy with rust as you are but it's not the language's fault its my own shortcomings

_"You can forget gang of four patterns..."_ But, they are forever etched into my smooth brain.

Great video!

Wooooooooo! New no boilerplate video!

rust curious here enum's are elegant, not a fan of ORM but how do you map your tables to enum's without boilerplate?

Algebraic data types are great for expressing data models and are understandable even by the business people. Together with Typeclases one can get closer to expressing the “real” world concepts.

This is one of the videos I'm gonna save for future reference, or as a quick link for friends who ask me "what's so great about rust?" Really well explained! I have a minor question about the very first point in the video about sum versus product types. Can't sum types be represented in any OOP language using either interfaces (and implementing classes) or subclasses with different attributes? Obviously you don't get things like match statements, which are absolutely lovely, but is there anything else I'm missing about why this is something that OOP languages can't do? Thanks!

It's interesting that you bring up the ORM vs. DAL divide -- I have personally not once ever heard of the term DAL before, and even after googling it a little, I still fail to see how it is really an opposite to an ORM in any way.

I would make NormalPost has many PostImage and when it comes to data/information modeling. Not sure if normal forms applies really in this case, modeling a domain doesn't need to follow DB design.

How does this compare to Kotlin’s sealed classes/interfaces with objects and data classes, and pattern matching with `when`? As far as features go, they seem to be equivalent. Is the only difference performance?

The fat enums with serialise macros also make it impossible to have invalid messages in client/server communications, in particular webserver/wasm, both written in rust. No need for Ajax or other url scheme, just specify operation as enums with parameters. Compiler prevents invalid message generation, and all messages must be handled