Linting Rust Code With Clippy CLI Rules 🤯🦀 Rust Programming Tutorial for Developers

hey guys my name is Trevor Sullivan and welcome back to my video channel thanks so much for joining me for another video in our rust programming tutorial series now the topic that we're going to be focusing on in this particular video is actually a tool that you can use in your rust workflow in order to write more robust and higher performance code plus you can actually learn more about the rust programming language by using this tool now typically this tool called clippy is included with an installation of rust when you use the rust up installer in order to install your rust tool chain which includes things like the rust dock CLI the cargo CLI and the rust compiler which is rust C now clippy is a really cool tool because it is able to kind of inspect your code files and make recommendations on what you can improve in your code project so ultimately when you use clippy to help provide guidance to you when you're writing your rust code you get more code consistency you get recommendations about maybe new techniques in your rust code that you didn't even know were possible and you can also ensure consistency across a team environment this is a really important thing when you start to have multiple team members that are all working on a similar project you know one team member might prefer a certain syntax or they might use a certain method but a different team member might use a different mechanism in order to accomplish the same task and so by using clippy it kind of provides these guard rails to make sure that your entire team is on board and following the same best practices for writing rust code now as I mentioned clippy is part of the rust tool chain however if you installed the minimal version of the rust tool chain then this component may not have been installed in fact it probably wasn't installed if you installed the minimal version of the tool chain but thankfully if you're using the rust up installer here you can simply specify that you want to add the clippy component into your rust installation and that'll get clippy installed in your environment and then you can go ahead and call clippy anytime that you want to now you can use clippy at the command line while you're building your rust code but you can also incorporate clippy as part of your CI CD pipelines so anytime that one of your team members does a git commit and then get push up to your code repositories as part of that CI CD pipeline that gets kicked off during that push event you can execute the clippy utility you can set up some configuration options as well in a configuration file as well as command line parameters and then if clippy catches any issues inside of your code you can actually abort execution of your pipeline and have the developer go back and fix whatever code issue there is and then go ahead and update do another git commit git push and fix those types of issues so you can use clippy as kind of a learning tool you can use it as a gatekeeping tool in a good way not a bad way and you can help just ensure that your team is writing consistent and high quality and high performance code now there are over 650 lints I know the clippy documentation book here says 600 lengths but if you check out the open source repository here for clippy you can see that in their latest version of their readme they do boast having over 650 linting rules available and when we talk about linting linting is basically just when a software utility inspects your source code files and looks for any potential enhancements that you could make or any potential errors that you could run into and this helps you to catch errors as early in your development life cycle as possible you don't really want to get you know maybe 20 minutes into a build process and then realize later down the line that you have an issue with your code it would be a lot better to get that immediate feedback from clippy early on in the development process so that as soon as you run into some kind of warning or error inside of your code you can go back fix that immediately push the updated code and get that feedback as quickly as possible so I highly recommend using clippy and you might be thinking as a rust beginner well why do I want to introduce more guard rails why do I want to introduce more issues when I'm already trying to learn the rust programming language and maybe hitting a bunch of brick walls well again this is going to provide a guidance based on these linting rules so the rules are configured to not only detect issues but also to provide recommendations and to deepen your understanding of what those specific issues are so that the next time that you write similar code like whatever you caught previously with one of these linting rules you can write code in a better way so I actually think that getting these errors and warnings from these utilities is a positive thing in your learning cycle of rust because you are able to have a tool that's providing those guard rails for you so look at this as something that's going to kind of come alongside you and help provide better recommendations on how to write rust code rather than looking at it as an inhibitor or something that's blocking you because it's actually helping you ultimately to write better rust code now these 650 lints those are a lot of different rules and they are categorized into these default categories in clippy so we've got clippy all we've got clippy correctness we've got suspicious style complexity performance related things and by default there are certain warning or allow levels that are applied to each of these categories so for example if you look at something around the cargo manifest files right those by Def defaults are going to be allowed but if you want specific rules to be caught as warnings or actually block execution and error out when you run the clippy utility then you can change the default level here from allow to maybe warn or deny we'll talk a little bit more about those levels in just a moment but basically each of these categories are broken down into these individual rules that Target very precise recommendations inside of your code so it'll look for certain patterns in your code it'll look for certain method calls it'll look at the maybe the number of arguments that you're passing into a function or maybe how long your function code is and things of that nature and some of these things actually have customizable parameters on them too there's actually a separate configuration file that we can use in clippy to kind of tell it how to apply these different rules so if we take a look at this configuration section right here there's a special file that you can add into your project called clippy.tomel or you can hide it with Dot clippy.tomel and it's going to look for that file in your project directory or you can actually specify an environment variable for where to locate that configuration file or you can specify this manifest directory where your cargo manifest is located but by default it's just going to look in the current directory wherever your shell is pointing to so that's kind of the easiest way to use it rather than having to set one of these environment variables but inside of this configuration file it's basically just an ini or Tamil kind of file format here but it doesn't really have any headings so you don't have those square brackets with the headings like you do in the cargo.tomo file all we do is we set a variable and we set the variable to a certain value and you can find all of these input configuration options or these variables and the supported values for them in the documentation for the actual lints themselves so if we take a look at the read me over here and then click on this link to go to the linking rules here that'll take us directly to this clippy lints page here and this is going to show you all of these individual rules and if you'd like to you can actually filter them by group here so we could say I would just want to see things related to my cargo.tommel configuration or maybe I want to see things that are performance related so I'll just click on none and then include the performance group right here and as you can see there are quite a few performance related rules right here and then once you find a rule like maybe let's take a look at uh two string for example so if you are using the print line macro here and you are taking a string as input and you call the tostring method on it in order to convert it to a string this rule is basically checking for that and saying hey it's not necessary for you to call tostring because the thing that you're passing in to this print line macro already implements the display trait and so therefore the print line macro is able to decipher how to convert that object input as a string representation so basically it's just going to recommend that you eliminate this two string method call and that will provide higher performance code now another nice thing about cargo is that it can actually fix some of these issues automatically unfortunately I didn't see any kind of specificity in here to determine if a rule is automatically fixable or not so you'll kind of have to play around with the individual rules to figure out if they are supported for automated fixing but there's a parameter called dash dash fix that you can pass in to the cargo clippy command and that will automatically trigger a fix for any of these issues for you if they support an automated fix also we've got these linting levels so I mentioned these briefly earlier and said we'd take a deeper look at them there's allow warn deny and none but there's actually a couple of other levels as well so if we go back and take a look at the clippy documentation and take a look at I think it's under the usage section here maybe let's see if it's in here let me just do a quick search and search for levels here so in any case the levels allow us to specify things like force Warn and force deny it which is also known as forbid as well I'm not entirely sure where that is in the documentation here but there's a force worn and a forbid option that you can set as well and those are not displayed inside of this interface here but you can use those to basically prevent somebody from overriding those particular rules now how do you actually enable these rules well there's really two different ways that you can do this number one is you can actually go directly into your source code and you can use an attribute in order to configure these lints and the other thing that you can do is actually specify the linting rules on the clippy command line so when you run cargo clippy to invoke the clippy utility you can actually specify which rules you want it to either warn or deny the access to in your code so this example right here is going to show you how to basically deny all rules this is an attribute syntax that you would use across an entire module or across an entire crate if you are specifying that in your lib.rs file so you can use this attribute-based syntax but you can also use this syntax down here where we can allow with Dash capital A there's also a dash dash allow that's kind of spelled out I generally prefer to use the spelled out parameters just because they're more clear if you're reading your code because Dash a is pretty ambiguous that could mean a lot of different things it could mean all it could mean allow it could mean a whole bunch of different things so I generally like to spell these out also dash dash warn or Dash capital W is how you can specify a warning level and if you want to deny something you can actually use Dash capital D or dash dash deny and then specify the name of the rule and you'll notice that when you specify the name of a rule it does need to be prefixed with clippy and then a double colon here and then you can specify the name of the rule so if you're looking at the list of lengths in this documentation right here just remember that you need to use the lint name prefixed by clippy double colon if you're using it inside of the command line when you run cargo clippy so in any case we're going to look at a couple of these rules and how we can incorporate them into our code and we'll take a look at the parameters on the cargo clippy CLI tool so that you can understand how it works in practice as well as the automated fixes that we can apply to our code in order to fix changes or fix issues in our code without having to go and manually seek out those issues and fix them on a line by line basis which can ultimately save you a lot of time when you're working on a large project but before we jump into our example I just wanted to invite you to subscribe to my YouTube channel here at youtube.com Trevor Sullivan I'm an independent content creator so any kind of support that you can provide to this channel is extremely helpful in the pinned comment below I'll leave some links that you can use as affiliate links and you can optionally use those to do some online shopping and if you make a purchase through there I'll get a small portion of the proceeds of that particular sale so please consider doing that also you can go out to my channel here and find the rust programming tutorial playlist we're up to 28 videos so this will be video number 29 and there's a whole bunch of rust Concepts inside of this playlist here that we go really into depth and Hands-On with so feel free to check out this entire playlist here and you know pick up any knowledge that maybe you have a gap on if you need threading knowledge if you need to learn about iterators and how to kind of work with the different methods on there if you want to learn about hash maps and hash sets there's a whole bunch of different Topics in here so feel free to go through this playlist also if you learned something from this video please leave a like on the video that helps to kind of promote to this video in the algorithm and also leave a comment down below and just let me know what you thought of this video the style and format and also let me know what other kind of rust topics you want to see on my channel and in this playlist right here so with that out of the way let's go ahead and spin up a brand new project and we'll take a look at how to use clippy so I'm going to switch over to my integrated development environment which is Microsoft Visual Studio code I'm running it on Windows 11 that's my development workstation locally but as you probably have seen in my earlier videos especially the first video I talk about how to set up a remote development environment against a remote Linux server so I actually have a virtual machine running with lexd which I have another playlist series on setting up Lex D on a bare metal Linux server and this virtual machine is just running a headless Ubuntu Server distribution using the latest LTS distribution of Ubuntu and I have vs code remotely sshed into that virtual machine so when I run a shell here and do use things like rust C then this is actually going to be running on a Linux distribution rather than on my local Windows system and this is really nice because it allows me to kind of switch back and forth between different systems and I have a consistent development environment so if I go use my laptop upstairs you know I can just load up my SSH session that I was working on on my development workstation in my office and I can just pick up where I left off so I'd strongly recommend that you invest some time into learning how to set up that remote development environment because in the long run it'll make you a more productive developer but as you can see I have rust installed here I've got the latest version of rust 1.72.1 and rust up is how you typically install rust especially on a Linux server and if we take a look at our components here we want to basically verify that clippy's installed so what we can do is say rust up and then go into this component context and then we can say list installed and available components so just do a rust up component list and then if you do a shift Ctrl F I think or maybe just control F in here and then search for clippy you can see that the cargo components installed the clippy component is installed rust docks are installed rust source is installed and there are a bunch of components that I don't need on this particular system that aren't installed but any of these bolded items here that have installed at the end are going to be present on your system if you want to inspect the file system to verify that clippy is installed then you can actually just go to your home directory so we'll say dollar home and we'll go into the dot rust up folder here then we can go into the tool chains folder right here and you can see I've got the stable tool chain I don't have nightly installed on this system and then if we go into that specific tool chain version we can take a look at bin and inside of the bin directory you should see that there's a cargo Dash clippy binary that you can execute so if we execute the cargo CLI and then run clippy afterwards then that's going to be how we invoke this utility so if we do cargo clip e dash dash help you can see we've got this dash dash fix parameter right here that allows us to automate fixes in our source code it also shows us how to use this attribute here to allow or deny or warn on certain linting rules in our code and then these options right down here are going to allow us to at the command line when we actually run cargo clippy we can specify warn allow deny and forbid as additional customizations for which rules we want to enable or disable right and then don't forget about the configuration file we'll take a look at some specific configuration options as we go through the individual rules but if we do something like let's search for args down here and go to all lint levels and we want to look for one called the number of arguments so if we take a look at I think it's number of arguments or argument count or something like that too many arguments so let's do that two many arguments so in this particular rule here you're basically just inspecting the number of arguments in a function and it has this configuration section so when you're looking at a lint rule for clippy you want to look at this configuration section and see if it specifies any additional configuration options and then these configuration options are what you can place into that Tamil configuration file specifically for clippy and that will customize how this specific rule executes against your code so let's go ahead and write some simple code in a project so we'll start by creating a project directory in here we'll just do a maker and then specify a folder like lint Dash test and then we'll go ahead and open that up so I'll do Ctrl K Ctrl o and we'll open up the lint test folder in our editor which will reload the window and get us connected to that specific project so now we have this empty folder and we'll just do a cargo in it in this directory and now we have our simple scaffolded out binary project here you could also do a cargo init and specify dash dash lib if you want to create a library instead with lib.rs but for now I'm just going to go ahead and create a binary application with a main entry point so now what we can do is start by specifying some rules in our code using attributes so let's actually use this example right here of too many arguments and let's say that we want to prevent or deny a build of our code if we have too many arguments so we want to use the deny attribute in our code so we do a hashtag and then an exclamation point and then we can say deny and then inside of this deny attribute we can specify which linting rules we want to block the build on so in this particular case we can just hit control space and see a list of all of these different rules right here and so we want to use the two many arguments rule so we'll pass in clippy double colon and then two many arguments and that way if we have more than by default seven arguments you can see right down here the documentation says it defaults to seven so if we have eight arguments in our function definitions then that will breach this Rule and cause an issue so for starters before we actually apply the customization Let's do let's declare a function called test lint and inside of the function declaration here let me just call it so that it's not complaining about us not calling it here and inside of the function definition we're going to specify eight arguments so we'll say ARG one is a u8 and then I'll just duplicate that two three four five six seven eight times and we'll just rename these to arg2 ARG three ARG four ARG five six seven and eight all right so now we have eight input arguments here and of course it expects eight inputs I'll do one two three four five six seven eight and so now I should ultimately be blocking the build based on these arguments here now it looks like I have a little syntax error here so let's see what's going on right curly brace I have a left one over there I have a right one over there not really sure what's going on here let me just do a cargo build and it looks like we have an unclosed delimiter somewhere so where is that oh I killed off the right curly brace for main so let's go ahead and include that and so now we should be getting an error or a warning it's indicating that we have too many arguments here now this is just complaining about unused variables here but let's see if we can force it to fail so if I do a cargo and then clippy command that's going to invoke the linter and as you can see when I invoke clippy with cargo clippy it's going to look at these attribute based rules that we've declared in our source file here and it's going to parse those it's going to look for any configuration options for those linting rules and then evaluate my code using static analysis in order to see if there's any issues and as you can see it says error this function has too many arguments it says the rule indicates that we want seven again that's the default I haven't customized that in my clippy configuration but we actually have eight arguments so now let's say that I want to customize the number of arguments that are going to cause a breach of this rule also one more thing really quick if we do Echo dollar question mark here in bash you can see that we get an exit code of one zero one so if you're in a CI CD Pipeline and you're doing Automation in there you can just inspect that exit code and see if it's 101 or non-zero and that will indicate that there was some kind of error that occurred in the clippy linting and then you can just immediately abort the build process abort the CI CD Pipeline and that'll save you a whole bunch of CI CD minutes if you're using a SAS vendor to do CI CD and you're paying by the minute like with GitHub actions or maybe Circle Ci or Travis CI something like that and so that's a really nice way to just kind of detect if there were any issues also we can just change this to warn and say instead of denying I want to just warn on that and then if we warn we're not going to get a non-zero exit code we'll just get a zero exit code but in the standard output we're still going to see that that there was some recommendation here so now what we're going to do is to customize the number of arguments so the default for this too many arguments lint rule was seven arguments so we put eight arguments to breach the rule but let's say that we wanted to customize that and say I want a maximum of about four arguments so again we're going to grab this configuration option right here that allows us to customize this specific rule for too many arguments and we'll create a new configuration file in our project here we'll call it dot clippy dot Tamil and you don't have to put the period at the beginning it'll look for clippy.tomel as well and then all we need to do is paste in that setting and set it to the value that we want so our functions can have a maximum of four parameters and if we breach that then we're going to warn on that issue or I'll actually change it back to deny so now we'll do cargo clippy and as you can see we have eight but it wants only four now so that's how we apply that customization option to this lint rule so now if I eliminate these extra arguments here and I'll just put them in a comment in case I need to put them back now we can eliminate these from the inputs here and now this should satisfy the rule so if we do cargo clippy again you can see that we're getting warnings about unused variables but we're no longer getting the warning or the denial rather the error saying that we have too many arguments of course if we went back and added ARG number five again and re-ran cargo clippy then we are going to get that error along with the 101 exit code so that's how we can apply the attribute for denying this particular rule to the entire crate because the hashtag exclamation point applies to the parent so main.rs is parent is the crate itself so this should apply to our entire crate and we can also apply things to individual entities as well so if we want to do that let's say maybe we want to allow unused variables right so let's do something like unused and we'll search for unused argument I think let's do a search for argument or unused variable Maybe and I'm not seeing that show up here but there is one for allowing unused variables I'm not sure maybe that one's not actually a clippy rule but let's check out some other types of warnings that we might have right here and see if we can find another one so uh I think another one is actually the two string so let's go ahead and search for tostring right here and I think that that was going to be a warning a performance related category warning so let's go ahead and try to use this inside of an example so if we have a type that implements the display trait and we call tostring on it it should catch that as a warning and as you can see there's no configuration section here at the bottom so there's no additional configuration options for this particular setting so what we're going to do is just Define what is this two strings so we'll Define another test function here we'll say test string and let's also fix this we'll go ahead and remove that fifth argument there so that that's Happy so what we can say down here is that we want to allow unused variables so let's say let x equal five we could also use arguments as inputs like ARG one is a unsigned 16-bit integer and so as you can see we get unused variable unused argument and unused variable again right down here so if we want to allow unused variables only on this particular function here we can just use a hashtag without the exclamation point and that's going to apply to the item directly following the attribute definition so we could say allow and then specify unused variables down here and I don't think this is a clippy rule because it doesn't get prefixed with clippy here and I also couldn't find it in the clippy docs here so just be aware that that one I think is just built into rust here so now you can see that those warnings immediately go away if we run cargo clippy here then you can see we just get function test string is never used but we don't get those unused variable warnings like we do for this function called test lint up here so if we comment out that attribute and rerun cargo clippy we should get an unused variable here on the test string function now and previously it was only reporting on unused arguments or variables on the test lint function so it's complaining that we're not using the argument ARG one on the test string function and it's complaining that we're not using the X variable that we declared inside of the test string function body but the rule that we wanted to test out was the tostring rule right down here so what we'll do is go ahead and just do a print line operation here let's do print line we'll specify curly braces and then we'll pass in I think X I'm not sure if it explicitly display implements display but I'm guessing it probably does we could also just use a string value like hello from rust Trevor and then we'll pass in X yeah that's fine it's a string and then we can do dot two string here so now we're taking a string slice and we're actually converting it into a heap allocated string by calling the two string method on it so now if we do cargo clippy then you should see this warning right here that says two string was applied to a type that already implements the display trait so this is uh again a performance related thing that's saying hey you don't actually need this tostring method call here so go ahead and eliminate it and your code will still work perfectly fine right so once we rerun this here we no longer get that warning and that's helping to improve the performance of our application by providing that linting guard rail by default again the default level for that particular rule is to warn so it's not going to allow it by default but there are some things that are allowed by default that you can enable warnings or deny operations for such as these right here if you just filter by the allow rules right here then these are types of things that are be allowed by default but you can enable them in your configuration you can actually set a warning attribute or a deny attribute so in order to specify these rules at the command line that's kind of the second way so far we've taken a look at the attribute based syntax here that applies at the crate level the parent level and the individual function level or individual struct level enums and traits and that kind of thing but if we want to include some of these rules in our CLI here we can do cargo clippy take a look at the help and then we can warn allow deny or forbid certain things inside of our code and the 4-bit is going to be the most strict because that's not that's going to basically ignore any overrides that you have so that's uh that's kind of the most strict option if you want to forbid things in your code but let's just say that for now we want to maybe allow let's see let's allow the tostring function right here so we'll do x.2 string again but this time we're going to go ahead and specify that we want to allow it in our clippy CLI rather than specifying it as an attribute based syntax here so what we'll do is say cargo clippy and then put dash dash here because that will prevent any arguments from being passed to Cargo anything after the dash dash will be interpreted by clippy itself not cargo and so what we want to do is say we want to maybe allow the clippy and then what's it called let's do a filter on two string warnings here so it's called two string in format args so we want to basically do clippy double colon and then two string in format args so let's see can I copy that from somewhere here I'll just copy it here we'll click that button and then we'll do clippy double colon and paste that in oh of course it when I copied it included the prefix there so now if we run this you can see that we don't get that particular warning if we run without that parameter we do get this warning saying that two string was applied to the type that already implements the display trait but if we run with the dash dash allow here that will eliminate that warning from popping up also if we wanted to change that warning into a deny we could simply specify dash dash deny instead of allow and so now this is going to cause an error during the clippy invocation and that'll catch that rule early and now we get a 101 exit code so again we can abort our pipeline so those are really the two ways to apply things we can do it at the attribute level for kind of a global scope here across the entire crate we can do it I think that works at the module scope as well so if you have a sub module you could plug this attribute into there I think that would probably work and then we can also use this syntax here in order to apply to the element directly following and when I say element of course I'm referring to functions traits enums structs and things of that nature all right so let's take a look at the quick fixes or the automated fixes with clippy so one of the things you might have noticed from earlier is that when we do cargo clippy dash dash help the cargo CLI actually has a dash dash fix option so you want to pass this into cargo not into clippy so you want to put it before the Double Dash and that's going to be an option that gets past a cargo anything after the Double Dash gets passed to clippy specifically so if we do cargo clippy dash dash fix and then plug in our clippy options after that then we can apply automated fixes so let's see if there's an automated fix that'll remove this invocation of the tostring method so right now the way things currently stand is that if we run with a deny here we're going to get this error on tostring here because we changed it from a default warning into an explicit deny on our command line but now we're going to go right before these double dashes right here we're going to apply dash dash fix to that and as you can see by default it's going to warn us about uncommitted changes but very similar to doing a publish operation which I don't think we've covered yet publishing crates to the crates.io registry we can specify this parameter here called allow dirty and this will prevent us from needing to commit our changes with running this command so we can go ahead and just say allow dirty I think that's something we passed a clippy not cargo so let no it is actually cargo so let's move that before the Double Dash is here we'll put the Double Dash after that and now we should hopefully have a fix here so as you can see that automatically fixed our code we can do control Z to undo that change and then if I just bring this down a little bit here and rerun the cargo clippy command you can see that it automatically fixed that issue for me so I don't have to fix that because maybe I've got 100 or 200 different spots in my code where I was calling tostring unnecessarily that'll take care of fixing all of those instances for me so that I don't have to go manually seek them out and resolve them so that's a real Time Saver that you get with the clippy CLI tool so as you can see it is pretty powerful here there's lots of different rules that are spread across these different groups right here so this is really nice that it's grouped because if you want to look for performance related issues if maybe you're having some performance issues and you want to try to resolve specifically performance issues you can just filter by these performance-based rules here and see what you can find let me just clear that search and so all of these rules right here are performance related and we can just run clippy against all these different rules and see if they apply and also if any of these rules have configuration options like this one here we can also go ahead and specify those inside of our clippy.tomel file so feel free to play around with clippy in fact I strongly encourage you to get some Hands-On time with clippy maybe run clippy against an existing rust project if you've already started building your own rust project and just see what kind of warnings or errors it throws also make sure that you incorporate clippy into your CI CD workflows as well if you use using something like GitHub actions or gitlab CI CD or maybe onedev CI CD go into your configuration files and add this clippy command as an early step in your process to catch these errors as early as possible in your pipelines so that you're not waiting a long time for the build to complete and only then realize that you have some issues so strongly encourage you to play around with clippy play around some of these different rules play around with some of these different configuration options you can use the CLI or you can use the attribute-based syntax in order to apply the rule changes so if you decide to go the CLI route of course you would be specifying these CLI parameters in here in your CI CD configuration file whatever script it is that you're running in your CI CD pipeline you'd basically just add in all these deny and allow parameters inside of your CLI script that you're calling clippy with and then of course you can always check for that exit code of 101 to see if there is an issue or not and then you could either abort the pipeline or you could just maybe send an email or a slack message to your development team indicating that clippy caught some issues and then maybe proceed with the build if you're comfortable with that approach but again it's entirely customizable to each and every project that you are writing in Rust so in any case I think that's everything that I wanted to cover around the clippy utility I strongly encourage especially beginners to use it because it really does help guide you on writing better code it helps you learn more about the rust language and the standard library and it's just a great tool to have in your back pocket to help improve the efficiency of your rust builds so again if you learned something from the this video please leave a like on this video please leave a comment down below let me know what you thought of it and subscribe to the channel click on that Bell icon so that you get notifications when new videos are published and I'd love to hear your thoughts in General on this entire playlist thanks for watching and we'll see you soon take care

Channel: Trevor Sullivan

Views: 1,948

Keywords: rust, rustlang, rust developer, rust programming, rust software, software, open source software, systems programming, data structures, rust structs, rust enums, rust coding, rust development, rustlang tutorial, rust videos, rust programming tutorial, getting started with rust, beginner with rust programming, rust concepts

Id: _YFZZc5jIfY

Length: 39min 1sec (2341 seconds)

Published: Thu Sep 21 2023