Summary

With Rust, we have seen that there are some traps when coming from a dynamic programming language background. However, with a little bit of knowledge of referencing and basic memory management, we can avoid common pitfalls and write safe, performant code quickly that can handle errors. By utilizing structs and traits, we can build objects that are analogous to classes in standard dynamic programming languages. On top of this, the traits enabled us to build mixin-like functionality. This not only enables us to slot in functionality when it’s useful to us but also perform checks on the structs through typing to ensure that the container or function is processing structs with certain attributes belonging to the trait that we can utilize in the code.

With our fully functioning structs, we bolted on even more functionality with macros and looked under the hood of basic macros by building our own capitalize function, giving us guidance for further reading and debugging. We also got to see a brief demonstration of how powerful macros combined with structs can be in web development with JSON serialization. With what we have learned in this chapter, we can now write basic Rust programs. Because we understand the concepts that the borrow checker enforces, we can debug the application that we code. Like other languages, there are limited real-world applications that we can do yet. However, we do have the essential foundation to build real-world applications spanning multiple files running on our own local computers.  

We can now move on to the next chapter and investigate setting up a Rust environment on our own computers to structure files and code to enable us to build programs that can solve real-world problems.