Udemy

Free Rust Structs Course: Explore References, Enums and Modules

As a Rust program grows, the way its data is organized becomes as important as the individual statements it runs. This free English course by Ellie Sleightholm introduces references, structs, enums and the first steps toward using more than one source file. It suits learners who already recognize Rust’s basic syntax and want to give related values and operations a clearer structure.

Free learning access

Listed as Free on Udemy when checked on 6 November 2026. No coupon or subscription trial is required for the listed lessons. Enrollment needs a Udemy account; availability can change.

About this course

As a Rust program grows, the way its data is organized becomes as important as the individual statements it runs. This free English course by Ellie Sleightholm introduces references, structs, enums and the first steps toward using more than one source file. It suits learners who already recognize Rust’s basic syntax and want to give related values and operations a clearer structure.

The course is Part Three of a three-part beginner series. Its five videos span three sections and total one hour, nine minutes and thirty-four seconds. The sequence includes pointers and referencing, structs, enums, multiple files and a closing discussion. Watching the first two parts is strongly recommended by the instructor. Despite a section named More Advanced Concepts, the source level remains Beginner.

Official course Rust Programming Crash Course for Beginners (Part 3/3)
Created by Ellie Sleightholm
Platform Udemy
Language English
Level Beginner
Listed duration 69 minutes; 5 lectures across 3 sections
Completion terms Not included with a new free enrollment

What you’ll learn

Distinguish borrowing a value through a reference from transferring ownership. Explore named-field and tuple structs, methods associated with a type, enum variants that represent alternatives, and Option as a way to represent a present or absent value. Follow a small example of separating Rust code into modules and files.

Skills you’ll gain

  • References and borrowing basics
  • Struct design
  • Tuple structs
  • Methods and impl blocks
  • Enums and Option
  • Rust module organization

Ask who owns the value

The first lesson compares arrays and vectors while introducing references through the ampersand notation. This provides a useful starting question whenever a function receives data: does the function need to own the value, read it temporarily or change it? Those are different requirements. A reference can let code use a value without taking ownership of it, but it is not a general permission to use that value in any way or for any length of time.

Rust checks borrowing rules. For the same value, shared references and an active mutable borrow cannot simply overlap without restriction, and references must remain valid. Read compiler feedback in relation to where each reference is last used. This short lesson introduces the idea; it is not a complete treatment of lifetimes, unsafe pointers, aliasing or concurrent programming, and it should not be presented as a guarantee that every program you write is correct.

Group information with a purpose

The structs lesson introduces both named-field and tuple forms, creating instances, accessing fields and changing values. A named-field struct gives a related group of values an explicit meaning. Instead of passing several loosely associated pieces of information around, you can describe the thing they belong to and choose names that explain each field. The lesson uses education-related data to make this organization concrete.

Methods and impl blocks extend that model by attaching behavior to a type. While following the example, separate the data an instance stores from the operations that use it. Ask whether an operation needs to inspect an instance or change it, then connect that decision with borrowing. Small examples are useful because you can trace the relationship between the type definition, the instance and the method call without navigating a large application.

Represent alternatives explicitly

Enums address a different modeling need: a value can be one of several defined alternatives. The lesson includes an IP-address-kind example and variants that carry data. Focus on why those alternatives belong together, rather than treating an enum as a list of unrelated labels. An enum can make a set of possibilities explicit in the program, which gives later code a clearer basis for deciding what to do.

The sequence also introduces Option and match. Option represents either a value wrapped in Some or the absence of that value as None. Absence is not the same thing as a number being zero or a string being empty. When you examine an optional value, decide what the program should do in both cases. That decision belongs to the application; the type makes the distinction visible but does not invent the right response for you.

Organize code across files

The multiple-files lesson introduces another source file, module declarations, public functions and calling code from the main file. Moving code into a separate file can make a project easier to navigate, but the module structure still matters. The mod keyword declares a module; it is not a textual copy-and-paste instruction. Paths identify items in that structure, while visibility determines where those items may be accessed.

The recording was updated in April 2023, so consult the current Rust documentation when reproducing file layouts or interpreting diagnostics. Adding pub to one function does not eliminate every visibility or path requirement around it. Start by explaining one small cross-module call before splitting a program into many files. The closing video points toward further study, rather than adding a separate completed project or an advanced systems-programming qualification.

Sketch a small model before coding

For an editorial exercise, sketch a library-item record with a title and an enum describing its current status. Add an optional shelf label, then explain how a display function could borrow the record without taking ownership. This is a suggested design exercise, not a supplied or executed course project. It brings the topics together at a manageable scale. The free course is a foundation for practice, with no certificate, employment outcome or production-readiness promise attached to this description.

Enroll Now ↗

Related courses for your next step

  • Add a related skillBash Scripting

    Focus: Script setup · Interpreter selection

    Beginner

Compare course focus, level and study time
Compare the published course outlines. A lower level is a preparation option, not a required prerequisite.
Course Level Focus Study time
This course — Free Rust Structs Course: Explore References, Enums and Modules Beginner References and borrowing basics · Struct design · Tuple structs 69 minutes (Udemy listing)
Free Bash Scripting Course: Write Your First Linux Script Beginner Script setup · Interpreter selection · Shell builtins 44 minutes (Udemy listing)

Frequently asked questions

Can I start the series with this part?

The instructor recommends the first two parts. Knowing Rust variables, types, functions and basic control flow will help with references and custom data types.

Does this include a complete advanced Rust curriculum?

No. It contains five videos covering references, structs, enums, multiple files and closing comments. It is still categorized as Beginner.

Is None the same as zero?

No. None represents the absence of a value in an Option. Zero is an ordinary numeric value that could itself be present inside Some.

Share this course

Questions & discussion

Share a useful question or correction. Comments appear after moderation. Please avoid personal or sensitive information.

Add to the discussion

Your email address will not be published. Required fields are marked *