Rust Lessons

A Guide to the Rust Programming Language

  1. Lesson 1. Introduction to the Rust Language
    1. General overview of the Rust programming language. Installation
    2. First program
  2. Lesson 2. Rust Basics
    1. Program structure
    2. Variables
    3. Data types
    4. Data type conversion
    5. Arithmetic operations
    6. Bitwise operations
    7. Conditional expressions
    8. if..else construction
    9. Match construction
    10. Cycles
    11. Functions
    12. Function parameters
    13. Returning a value from a function
    14. Constants
    15. Anonymous functions and code blocks
    16. Short circuits
    17. Function type
    18. Function as a parameter and result of another function
  3. Chapter 3. Composite Data Types
    1. Motorcades
    2. Arrays
    3. Structures
    4. Tuple structures
    5. Enumerations
    6. Range Sequence
    7. Patterns and match construction
    8. Patterns and the if-let construct
  4. Chapter 4. Links and Ownership
    1. Context/scope
    2. Memory organization in Rust: Stack and Heap
    3. Ownership
    4. Links
    5. Modifiable links
    6. Ownership, borrowing, and closures
  5. Chapter 5. Object-Oriented Programming
    1. Methods
    2. Associated functions
    3. Trait
    4. Trait as a parameter and result of a function
    5. Generics. Generic types
    6. Generics. Generalized functions and methods
    7. Trait bound
    8. Global implementation of traits
    9. Operator overloading
    10. Associated types
    11. Trait objects
    12. Conditional matching of traits
    13. Type-level programming
    14. Debug and fmt::Display traits
  6. Chapter 6. Link Lifetime
    1. Annotations and link lifetime
    2. Reference annotations in functions
    3. Annotations of links in structures
    4. Reference annotations in method definitions
    5. Static lifetime
  7. Chapter 7. Collections
    1. Vector
    2. String
    3. HashMap
    4. HashSet
    5. Slice
    6. Iterators
    7. Collection Management
  8. Chapter 8. Modules
    1. Defining Modules: Privacy and Publicity
    2. Nested modules and the super keyword
    3. The use statement and module connection
    4. Defining a module in an external file
  9. Chapter 9. Error Handling
    1. Panic! macro
    2. Result Type
    3. The unwrap and expect methods of the Result type
    4. Handling multiple error types
    5. Operator?
  10. Chapter 10. Cargo
    1. Creating a project with Cargo
    2. Loading and using external dependencies
    3. Crates and packages
  11. Chapter 11. Input and Output
    1. Keyboard input
  12. Chapter 12. Pointers
    1. Unsafe context and pointers
    2. Smart signs
  13. Chapter 13. Multithreading
    1. Creating Streams
    2. Arc Smart Pointer
    3. Mutexes
    4. Mutex deadlocks
    5. RwLock
    6. RwLock Deadlock Management
    7. Inter-thread communication via channels
    8. Atomic
    9. Barriers
    10. Thread Local Storage
  14. Chapter 14. File System
    1. Working with catalogs
    2. Working with files
  15. Chapter 15. Unit Testing
    1. Introduction to Unit Tests
    2. Defining and running unit tests
    3. Conditional testing
    4. Error testing
  16. Chapter 16. Macros
    1. Procedural macros
  17. Chapter 17. FFI. Interacting with Native Code in C/C++ and Assembler
    1. Including C/C++ libraries in Rust code
    2. Compiling Rust and C/C++ code together
    3. Structures in Rust and C/C++

Explore More IT Terms


Share this term: Facebook X LinkedIn WhatsApp Email

Leave a Reply

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