rust-lang/rust-by-example

Features

• Interactive Sandboxes - Features an interactive code sandbox that allows users to execute and edit code snippets in real time.
• Programming Language Education - Serves as a comprehensive interactive tutorial for learning Rust syntax and systems programming concepts.
• Rust Tutorials - Provides comprehensive practical guides and interactive examples for learning the Rust programming language.
• Algebraic Data Types - Demonstrates the creation of enums that can hold varying types of associated data.
• Data Resource Duplication - Demonstrates how to create copies of resources via explicit methods to prevent ownership loss.
• User-Defined Types - Teaches how to create complex data types using structures and enumerations.
• Mutability Modifiers - Demonstrates the use of the mutability modifier to control whether variables can be changed.
• Immutable Shadowing - Rust prevents modification of a mutable variable by shadowing it with an immutable binding.
• Ownership-Based Mutability Transfers - Rust alters the mutability of a value by transferring its ownership to a new variable.
• Reference-Based Mutability Control - Rust controls whether data can be modified by using immutable or mutable references for access.
• Scope-Based Resource Cleanup - Illustrates automatic resource cleanup using the RAII pattern when objects go out of scope.
• API Documentation - Provides a practical reference and technical specifications for Rust APIs using verified executable examples.
• Interactive Coding Environments - Provides a live, web-based sandbox embedded in documentation for executing and testing code snippets in real time.
• System Programming Guides - Provides guidance on low-level operations including memory management, concurrency, and FFI.
• Custom Destructors - Rust executes specific cleanup logic via a trait implementation when a type is dropped from memory.
• Heap Allocation Strategies - Provides practical examples of allocating data on the heap using smart pointers for automatic cleanup.
• Ownership-Based Memory Management - Teaches memory safety through a system that tracks resource lifecycles and ownership transfers without a garbage collector.
• Cross-Thread Ownership Sharing - Implements examples of tracking references to heap-allocated values across threads to ensure memory safety.
• Shared Ownership Management - Implements reference counting to track and drop data only when the final owner is released.
• Collection Iterators - Provides examples of traversing data structures using various borrow types to process individual elements.
• Compound Data Structures - Provides examples of grouping multiple values using basic types like arrays and tuples.
• Expression-Oriented Evaluation - Demonstrates Rust's expression-oriented nature where blocks and statements return values.
• Function Definitions - Provides guidance on defining reusable blocks of code with typed arguments and return values.
• Generic Types - Illustrates using type parameters to create reusable logic across multiple data types.
• Immutable Constant Definitions - Shows how to define fixed, immutable values using literals and type suffixes.
• Module Interface Exports - Shows how to expose items from internal modules through a public interface for external consumers.
• Variable Declarations - Covers the syntax for declaring variables and binding them to values.
• Metaprogramming & Macros - Uses macros as a metaprogramming tool to eliminate repetitive logic and reduce code duplication.
• Custom Macro Definitions - Teaches how to create reusable macros to automate repetitive syntax generation.
• Ownership & Borrowing - Explains the rules for simultaneous immutable references or single mutable references to ensure memory safety.
• Variable Type Declarations - Explains the various ways to assign types to variables, including explicit annotations and inference.
• Module Importing - Demonstrates how to bind full paths to shorter names for simplified access to functions and types.
• Non-Owning Data Access - Shows how to pass objects by reference instead of by value to allow data access without destroying it.
• Function Lifetime Annotations - Demonstrates how to annotate function lifetimes to ensure returned references remain valid.
• Lifetime Inference - Covers the compiler's ability to automatically infer reference lifetimes to minimize manual annotations.
• Reference Lifetime Annotations - Provides a guide to defining explicit duration constraints on references for memory safety.
• Static Lifetimes - Rust specifies that a reference or type must persist for the entire duration of program execution.
• Rust Resources - Offers educational materials and technical guides for mastering memory-safe systems programming in Rust.
• Rust - Serves as a practical reference for Rust traits, generics, lifetimes, and ownership.
• Traits - Explains how to group related methods into shared behaviors using traits to ensure a consistent API.
• Struct Destructuring - Demonstrates unpacking values from structures and references using pattern matching syntax.
• Shared Behavior Interfaces - Teaches how to group related methods into traits to define consistent interfaces.
• Static Type Inference - Explains how the compiler determines variable types through analysis of values and usage.
• Type Conversion and Casting - Illustrates explicit casting between primitive data types using the 'as' keyword.
• Type Methods - Explains how to bind functions to specific types to implement method-based behavior.
• User-Defined Types - Teaches the use of both primitive and custom-defined types to represent data.
• Variable Assignments - Provides examples of binding values to identifiers using static typing and type inference.
• Arithmetic Operations - Covers the use of standard operators for arithmetic, bitwise, and logical computations.
• Integration Testing - Demonstrates how to verify library functionality by testing the public interface from an external crate.
• Software Testing - Provides a comprehensive guide to implementing unit, integration, and documentation tests within source code.
• Unit Testing - Provides practical examples of running isolated test functions to verify code behavior.
• Error Type Unifications - Teaches how to wrap different error types into a single trait object to simplify function signatures.
• Pattern Matching - Demonstrates how to bind values to identifiers during the pattern matching process.
• Dynamic Collections - Demonstrates the use of growable strings and vectors for managing dynamic sequences of data.
• Collection Iterators - Demonstrates how to implement custom iteration protocols for traversing data collections.
• Contiguous Fixed Arrays - Explains allocating same-type objects in contiguous memory with a compile-time fixed length.
• Slice Destructuring - Provides examples of destructuring arrays and slices through pattern matching.
• Field Visibility Controls - Demonstrates restricting access to data fields within a structure to encapsulate internal implementation details.
• Key-Value Stores - Provides practical examples of using growable collections to map unique keys to values.
• Parallel Processing - Shows how to distribute computational workloads across multiple CPU cores to process data chunks in parallel.
• Documentation Generators - Shows how to generate structured technical documentation from source code comments and signatures.
• Parallel Execution - Provides examples of running multiple tasks concurrently to improve program performance.
• Compiler-Verified Examples - Provides a system that executes embedded code blocks during the build process to guarantee all documentation examples remain functional.
• Asynchronous Message Passing - Demonstrates non-blocking communication between threads using sender and receiver endpoints.
• FFI Invocation - Demonstrates how to link and execute functions from external C libraries using extern blocks.
• Inline Assembly Interfaces - Shows how to embed machine instructions directly into Rust code for low-level hardware access.
• Unsafe Blocks - Provides examples of using unsafe blocks to dereference raw pointers by bypassing standard safety checks.
• Anonymous Functions - Teaches how to define anonymous functions that capture variables from the surrounding environment.
• Bidirectional Type Conversion - Shows how to define bidirectional transformations between different data types.
• Compile-Time Flag Evaluation - Demonstrates how to use configuration attributes in boolean expressions to trigger different logic.
• Compile-Time Type Constraints - Explains how to use generic type parameters as markers for static type checking.
• Complex Type Unpacking - Illustrates how to unpack values from nested types within match arms.
• Conditional Branching - Provides examples of using if and else blocks to control program execution.
• Conditional Loop Execution - Demonstrates how to implement while loops for conditional iteration.
• Fallible Type Conversion - Illustrates the use of fallible conversion patterns that return a Result.
• Function Argument Passing - Explains the mechanisms for passing both standard functions and closures as parameters to other functions.
• Associated Types - Demonstrates how to use associated types in traits to simplify API signatures.
• Generic Traits - Explains how to define and implement traits that accept generic type parameters.
• impl Trait Syntax - Demonstrates the use of impl Trait for cleaner generic function signatures.
• Trait Bounds - Teaches the use of trait bounds to separate requirements from type declarations.
• Trait Constraints - Shows how to constrain generic type parameters to specific trait implementations.
• Pattern Matching - Implements conditional execution logic using match expressions to evaluate values against patterns.
• Match Guard Filtering - Provides examples of using match guards to add conditional filters to patterns.
• Operator Overloading - Shows how to implement specific traits to define custom behavior for built-in operators.
• Derived Implementations - Provides examples of using the derive attribute for automatic trait implementation.
• Trait Object Polymorphism - Illustrates how to return different concrete types that implement the same trait via trait objects.
• Macro Argument Specification - Shows how to specify token types for macro arguments to match specific language constructs.
• Macro Overloading - Demonstrates how to use multiple input patterns in a single macro to handle different argument templates.
• Variadic Macros - Provides examples of creating macros that handle an arbitrary number of input arguments.
• Type Aliasing - Provides examples of creating type aliases to simplify complex type signatures.
• Shadowing Bindings - Demonstrates how to reuse variable names to declare new bindings for value transformations within a scope.
• Loop Labels - Demonstrates the use of loop labels to control nested iteration and termination.
• Loop Value Returns - Shows how to return a value from a loop using the break statement.
• Module Path Resolution - Illustrates the use of relative and absolute paths to resolve items within a module hierarchy.
• Multiple Return Values - Demonstrates using tuples to group different types and return multiple values from functions.
• Namespace Imports - Explains how to simplify item access by importing modules and names into the local scope.
• Numeric Range Iteration - Demonstrates how to use inclusive and exclusive range notation for controlled loop iteration.
• Diverging Fallbacks - Shows how to use diverging blocks as fallbacks during pattern matching.
• Pattern-Match Loops - Implements loops that execute based on whether a value matches a specific pattern.
• Domain Specific Languages - Demonstrates how to embed a mini-language within a macro to provide concise custom syntax.
• Generic Lifetime Constraints - Explains how to use generic lifetime constraints to prevent errors in complex types.
• Method Lifetime Annotations - Demonstrates how to specify reference validity when passing data into structure methods.
• Struct Lifetime Annotations - Shows how to annotate structures to ensure internal references remain valid.
• Trait Lifetime Annotations - Demonstrates how to specify reference durations within trait methods to maintain memory safety.
• Trait Bounds - Provides examples of requiring a generic type to implement multiple traits simultaneously.
• Trait Dependencies - Explains how to define trait dependencies where one trait requires another.
• Enum Variant Destructuring - Demonstrates how to extract values from different enum variants using match.
• Reference-Binding Patterns - Shows how to create references to struct or tuple fields during matching to prevent ownership loss.
• Tuple Destructuring - Provides examples of destructuring tuples within match expressions.
• Generic Function Definitions - Shows how to define functions that operate on multiple types using type parameters.
• Partial Move Execution - Illustrates moving specific fields out of a structure while retaining others for continued use.
• Sequence Iteration - Teaches how to traverse ordered collections to locate elements satisfying specific conditions.
• Slices and Sequence Referencing - Illustrates how to borrow contiguous sections of arrays using pointers and lengths.
• String Parsing - Provides examples of parsing string slices into specific numeric or custom types.
• Textual Data Management - Guides the use of heap-allocated strings and fixed-size slices for manipulating encoded text.
• Generic Method Implementations - Illustrates writing method implementations that operate on a variety of types.
• Variable Scope Controls - Explains how to constrain the lifetime of a binding to a specific block using braces.
• Item Attributes - Demonstrates the use of attributes to define test functions and control compilation.
• Function Argument Passing - Demonstrates how to pass closures into functions using trait bounds for flexible logic execution.
• Conditional Compilation Attributes - Provides guidance on selecting platform-specific code paths during the build process using attributes.
• Infinite Loop Execution - Implements infinite loop patterns using the loop keyword until a break condition is met.
• Directory-Based Organization - Illustrates mapping modules to a directory hierarchy to organize logic into manageable files.
• Dynamic Arrays - Covers the use of resizable arrays that dynamically manage capacity during execution.
• Error Handling - Provides patterns for detecting, reporting, and resolving errors using early return mechanisms.
• Error Handling Patterns - Demonstrates architectural patterns where errors are explicit return values requiring mandatory handling.
• Monadic Error Handling - Demonstrates the use of container types to manage failure without throwing exceptions.
• Automatic Error Conversions - Explains how Rust automatically converts errors into different types when returning them from functions.
• Error Type Compositions - Explains how to manage interactions between disparate error types to make them composable within a single flow.
• Result Transformations - Demonstrates chaining operations on success values while automatically passing errors up to the caller.
• Error Propagation Systems - Demonstrates mechanisms for propagating errors through application hierarchies to avoid deep nesting.
• Custom Error Type Definitions - Provides guidance on creating specialized error types to mask multiple failure modes under a single type.
• Error Wrapping - Illustrates encapsulating external error types within a single custom type for unified error reporting.
• Item Visibility Control - Shows how to restrict or grant access to module items using visibility modifiers.
• Message Passing Channels - Implements synchronized communication primitives to exchange data between concurrent tasks.
• Optional Value Types - Explains the use of data structures that represent absent values to prevent null-pointer errors.
• OS Thread Spawning - Teaches how to spawn native operating system threads for parallel task execution.
• Type Safety Wrappers - Shows how to wrap primitives in distinct types to prevent logic errors through type safety.
• Automated Test Suites - Includes a system to run unit, integration, and documentation tests to verify software correctness.
• Example Verification - Implements automated verification of embedded code blocks during the build process to ensure documentation accuracy.
• Panic Assertions - Shows how to implement tests that verify a function panics under specific conditions.
• Test Execution Filtering - Illustrates how to execute specific subsets of tests using name patterns.
• Programming Language Guides - Collection of examples illustrating Rust concepts and libraries.
• Rust in practice - Listed in the “Rust in practice” section of the Rust Learning awesome list.

Star history