rust-lang/rfcs

Features

• Lifetime Inference - Defines the borrow checker with lifetime inference, a core architectural principle of Rust.
• Language Change Proposals - Defines the complete RFC-based process for proposing and reviewing changes to the Rust language.
• Error Object Downcasters - Provides the downcasting mechanism for inspecting concrete error types through the Error trait object.
• Macro Export and Re-export Mechanisms - Defines #macroexport and #macroreexport for sharing macros across crates.
• Macro Matcher Set Computations - Computes FIRST and LAST token sets for macro matcher fragments in Rust.
• Debugging Display Formatters - Defines the Debug formatting trait and its {:?} specifier for developer-oriented type representation.
• Field Visibility Controls - Defines the language's struct field visibility model with per-field pub annotations.
• Collection Range Slicing - Defines the range-based slicing API for Rust's standard collection types.
• Value-to-String Conversion Methods - Defines the to_string method for converting values to strings via the Display trait.
• Mutability Suffix Conventions - Standardizes the _mut suffix for mutable borrowing variants across the Rust API.
• Full Stream Reads - Defines the fundamental read operation for I/O streams in Rust's standard library.
• Private Field Construction Restrictions - Defines the language's access control rules for tuple struct construction across module boundaries.
• Compiler Major Change Proposals - Defines Major Change Proposals for compiler decisions beyond simple pull requests.
• Generic Type Defaults - Defines default types for generic parameters to reduce boilerplate in Rust.
• Backward-Compatible Additions - Specifies how to add generic parameters with defaults to existing Rust types.
• Default Associated Items - Defines the mechanism for providing default values for associated types and constants in traits.
• Inference Fallbacks - Describes how default type parameters are used as fallbacks during type inference in Rust.
• Duration Data Types - Defines the standard library's Duration type as the fundamental time span representation.
• Path Property Queries - Defines the standard API for querying file path properties in Rust's standard library.
• Constant Function Invocations - Invokes constant functions from any constant expression, including static and thread-local initializers.
• Design Proposal Reviews - Defines the review process for RFC design proposals with community feedback.
• Macro Matcher Validations - Validates macro matcher syntax against FIRST and FOLLOW constraints in Rust.
• Accepted Feature Trackings - Tracks accepted RFC implementations through associated issues in the repository.
• Single-Call Stream Writes - Defines the fundamental write operation for I/O streams in Rust's standard library.
• Unsized Coercions - Defines the compiler-generated unsized coercion mechanism that enables smart pointers to work with dynamically-sized types.
• Buffered Text Reading - Defines buffered stream reading with line and byte-delimited reading in the standard library.
• Canonical Path Resolution - Provides canonical path resolution using the platform's realpath function in the standard library.
• Allocation Symbol Interfaces - Defines the low-level allocation symbols that custom allocators must implement in Rust.
• Default Allocator Overriding - Replaces the default memory allocator with a custom implementation in Rust programs.
• Allocator Crate Annotations - Uses crate attributes to mark allocator providers in Rust.
• Explicit Mutable Reference Patterns - Defines explicit syntax for mutable reference patterns in Rust's pattern matching.
• Shared Reference Send Restrictions - Makes &T implement Send only when T is Sync, preventing non-threadsafe shared references from being sent between threads.
• Unsafe Blocks - Provides explicit unsafe blocks for raw pointer operations while maintaining safe reference guarantees through the borrow checker.
• Binary Data Literals - Defines byte and byte string literal syntax for embedding ASCII data as u8 values.
• Block Expression Evaluations - Evaluates a block expression at compile time, allowing items and a trailing constant expression to define static values.
• Cross-Crate Macro Path Resolutions - Defines the $crate metavariable for correct cross-crate macro path resolution.
• External Macro Imports - Defines the #macro_use attribute for importing macros from external crates.
• Public External Crate Exports - Defines public extern crate declarations to expose dependencies without re-exporting.
• Character and String Writers - Defines the core API for writing characters and string slices to output streams in the standard library.
• Fragment Specifier Follow Sets - Defines follow sets for macro fragment specifiers to prevent ambiguous parsing in Rust.
• Constraint Bounds - Defines the syntax for constraining associated types with trait bounds and equality constraints in where clauses.
• Inherent Associated Items - Defines the ability to declare associated types, constants, and lifetimes directly on structs and enums without a trait.
• Input-Output Distinctions - Defines the distinction between input type parameters and output associated types for trait impl selection.
• Path References - Defines the path syntax for accessing associated types, constants, and functions via type- or trait-qualified paths.
• Associated Items - Defines the mechanism for declaring associated types, constants, lifetimes, and functions within traits.
• Numeric Type Traits - Defines the core numeric trait hierarchy used for generic programming over primitive types in Rust.
• Non-Local Impl Inference Prevention - Restricts trait resolution to only consider the self type parameter when selecting an implementation, preserving package concatenation.
• Late-Bound Lifetime Instantiation - Defines the fresh instantiation of late-bound lifetimes each time an associated item is accessed from a higher-ranked trait reference.
• Lifetime Binding Distinctions - Defines the distinction between early-bound and late-bound lifetime parameters on impls for higher-ranked trait references.
• Variance Constraints - Defines the variance constraint mechanisms for type parameters in Rust's trait system.
• Gradual Trait Obligation Resolution - Accumulates pending trait constraints during type checking and resolves them only when more type information is needed or at function end.
• Human-Readable Serialization - Defines the Display trait for human-readable string formatting of types in the standard library.
• Constant Function Body Restrictions - Limits constant function bodies to side-effect-free expressions and immutable references, preventing runtime-dependent behavior.
• Constant Function Declarations - Marks free functions and inherent methods as constant, enabling their use in constant contexts with constant arguments.
• Governance Processes - Defines the community-driven governance process for managing Rust's evolution through RFCs and consensus.
• Recursive Field Coercions - Specifies the recursive coercion algorithm for smart pointer fields, a key part of Rust's type coercion system.
• Unsized Coercions - Defines the CoerceUnsized trait that enables custom smart pointers to participate in unsizing coercions.
• Debug Trait Derivation - Specifies the derive macro for automatically implementing the Debug trait on user-defined types.
• Display - Defines the Display trait and its conventions for user-facing string representation in the standard library.
• Recursive Overlap Verifications - Verifies that no two trait implementations overlap by recursively examining their bounds and the orphan rules.
• Type Position Expansions - Expands macros in type positions so developers can generate complex type expressions programmatically.
• Macro Expansion Engines - Defines the macro expansion system that expands macros at compile time using pattern matching and hygiene rules.
• Module-Scoped Macro Visibilities - Defines #macro_use on modules to control macro visibility within the module tree.
• Macro FOLLOW Set Computations - Computes FOLLOW sets for macro matcher fragments to ensure forward compatibility in Rust.
• Auto-Deref Rules - Automatically dereferences borrowed pointers through dereference implementations to eliminate explicit cross-borrowing.
• Borrowing Mode Suffix Conventions - Defines the naming convention for function variants to indicate borrowing mode in Rust APIs.
• Fixed-Length Declarations - Specifies the syntax for declaring fixed-length array types in Rust.
• Subtyping Checks - Defines the subtyping algorithm for higher-ranked trait references using skolemization.
• Trait Bound Polymorphism - Defines the for<'a> syntax for declaring trait bounds that are polymorphic over lifetimes.
• Receiver Coercions - Defines the coercions applied to method call receivers, including dereferencing, referencing, and unsizing.
• Smart Pointer Coercions - Defines the CoerceUnsized trait mechanism enabling custom smart pointers to participate in unsizing coercions.
• Community-Driven Specifications - Defines the community-driven RFC process for evolving the Rust language through structured proposals and review.
• Lexical Tokenizers - Defines a complete, unambiguous token grammar for Rust to simplify tooling.
• Marker Traits - Defines marker traits that classify types without methods, using phantom functions for variance modeling.
• Programming Language Tokenizers - Produces annotated token spans including whitespace for Rust source code.
• Temporary Lifetime Extensions - Defines rules for extending temporary lifetimes when bound in let statements in Rust.
• Self Type Expansions - Describes how Self type is expanded to the concrete implementing type in Rust.
• Trait Bounds - Defines the trait-based type system with associated types, bounds, and coherence rules for generic programming.
• Move Restrictions - Prevents moving individual elements into or out of fixed-size arrays when the element type does not implement copy, while still allowing borrows and copies.
• Range Syntax Distinctions - Specifies distinct syntax for inclusive and exclusive ranges in Rust's language design.
• Repeated-Value Array Initializers - Defines syntax for creating arrays with repeated values in Rust.
• Site-Specific Coercions - Defines the specific program sites where implicit type coercions are applied, such as variable declarations and function arguments.
• Standard Input/Output Streams - Defines the standard output stream access API in Rust's standard library.
• String-to-Numeric Conversions - Defines the standard FromStr and ToString traits for converting between strings and numeric types.
• Type Conversion and Casting - Defines explicit type casting via the as keyword for numeric, pointer, and primitive conversions.
• Integer Overflow Detections - Defines the language's runtime integer overflow detection behavior as a core safety mechanism.
• Wrapping Arithmetic Operations - Defines wrapping arithmetic methods for integer types in the standard library.
• Floating-Point Classification and Decomposition - Ships the standard classification and decomposition methods for floating-point types in Rust's standard library.
• Saturation Arithmetic - Provides checked and saturating arithmetic operations that handle overflow safely for all integer types.
• Transcendental and Rounding Functions - Provides the standard set of mathematical functions for floating-point types in Rust's standard library.
• Compiler Change RFCs - Defines the RFC process for significant user-facing compiler changes.
• Function-to-Closure Coercions - Defines the automatic coercion from function items to closure types, a key part of Rust's type system.
• Cross-Platform Abstractions - Provides cross-platform I/O, threading, and system interfaces through extension traits and platform-specific submodules.
• Deprecation Management - Defines the process for marking old functions as deprecated while maintaining compatibility wrappers.
• Generalized Error Handling for Custom Types - Extends the ? operator to work with Option and other custom carrier types beyond Result.
• Automatic Error Conversions - Automatically converts errors from different libraries into a single target error type via the From trait.
• Chained Error Builders - Records a cause chain on errors crossing abstraction boundaries for downstream inspection.
• Display-Based Error Messages - Defines the Display-based error message convention used by all standard library error types.
• Standardized Error Traits - Defines the standard Error trait with description, detail, and cause methods for all error types.
• Question Mark Error Propagation - Implements the ? operator for concise error propagation from Result types to callers.
• Compiler RFC Triages - Defines the triage process for compiler RFCs with sub-team assignment.
• Block-Level Error Catchers - Implements the catch block construct for capturing propagated errors from ? operator usage.
• Variance Error Diagnostics - Defines the compiler error messages for unconstrained type parameter variance in Rust.
• Governance Proposal Lifecycles - Defines the complete lifecycle for proposing, reviewing, and implementing language changes through structured RFC documents.
• Feature Proposal Postponements - Defines the process for postponing RFC proposals with a dedicated label.
• Proposal Postponements - Defines the process for postponing RFC proposals with a dedicated label.
• RFC Replacement Proposals - Defines the process for creating replacement RFCs for non-minor changes.
• Bit-Level Integer Operations - Defines the standard bit-level operations on integer types used throughout Rust's standard library.
• Compound Assignment Operators - Defines traits for compound assignment operator overloading in Rust's type system.
• Ownership-Variant - Defines naming conventions for function variants based on ownership and borrowing semantics.
• Shadowing Prevention - Prevents redeclaring a type or lifetime parameter with the same name in the same scope, catching the conflict early during compilation.
• Underscore Omission Syntax - Specifies underscore syntax for omitting type parameters in Rust.
• Variance Inferences - Specifies how Rust's compiler automatically infers variance for type and lifetime parameters.
• Active RFC Amendments - Defines the process for submitting minor modifications to accepted RFCs.
• RFC Lifecycle Stage Managements - Defines the stage management process for RFCs from draft to active status.
• RFC Review Lifecycle Trackings - Manages the full review lifecycle of RFC proposals from submission to decision.
• Variance Constraint Markers - Defines the use of phantom data markers to constrain variance inference for unused type or lifetime parameters.
• Thread-Safe I/O Errors - Makes I/O errors thread-safe by adding the Sync bound for sharing across threads.
• Accepted RFC Amendments - Defines the process for submitting minor amendments to accepted RFCs.
• Accepted RFC Implementations - Guides the implementation of accepted RFCs through pull requests.
• Stdout Ignorance on Print - Silently discards output when stdout is unavailable instead of panicking during println! calls.
• Init-Last Slice Destructuring - Defines the split_last method for ergonomic slice access in Rust's standard library.
• Collection Append Operations - Defines the append operation for moving elements between collections in the standard library.
• Draining Iterators - Defines the drain method for clearing collections while reusing allocated memory.
• Head-Tail - Defines the split_first method for ergonomic slice destructuring in Rust's standard library.
• Whitespace - Provides standard library string splitting by whitespace with empty segment filtering.
• Stream Position Management - Defines the seek operation for controlling read/write position in Rust's I/O streams.
• Full Stream-to-Buffer Reads - Defines the readtoend method for consuming entire streams in Rust's standard library.
• Multi-Query Text Search APIs - Defines the standard library's regex API with separate functions for different match query types.
• Text Search and Replace - Provides standard library regex-based text splitting and replacement with capture group support.
• Stream-to-Stream Data Copies - Defines the copy method for transferring data between I/O streams in Rust's standard library.
• Target-Specific Build Settings - Limits dependency resolution and compilation to specific target triples so builds work correctly across different operating systems.
• Duration Formatters - Implements Display for Duration to format it as a human-readable time span string.
• Duration Component Inspectors - Ships standard library methods to decompose a Duration into its seconds and nanoseconds components.
• Duration Constructors from Units - Provides standard library constructors for creating Duration values from various time units.
• Duration Arithmetic Operations - Defines the standard library's Duration type with arithmetic operations and overflow handling.
• Linting Plugins - Registers custom lint passes by calling dedicated methods on the plugin Registry.
• Format String Localization Removal - Documents the decision to remove compile-time localization features from the format string system.
• UTF-8 Formatting Enforcement - Specifies that the formatting trait enforces UTF-8 validity for string output.
• Symlink Self-Metadata Reads - Defines the symlink_metadata method for reading link attributes in Rust's standard library.
• Native Build Scripts - Compiles and links native libraries during package builds using Rust-based scripts that manage dependencies and detect the target platform.
• Dependency Declarations - Specifies which C libraries a package provides and links to, preventing duplicate linkage across the dependency graph.
• External Linkage Type Controls - Delegates dynamic or static linking decisions to external build tools and environment variables.
• ASCII Case Converters - Ships standard library methods for ASCII-only case conversion on strings and characters.
• ASCII Character Property Checkers - Ships standard library methods for checking ASCII character properties like isascii, isascii_lowercase.
• Symbolic and Hard Link Creations - Defines the link and symlink creation APIs in Rust's standard library.
• Debug-Only Assertions - Provides a debug_assert! macro that is compiled away in release builds for zero-cost debugging.
• Send Permissiveness Rules - Documents the specific rule permitting &mut T to be Send even when T is not Sync.
• Unsafe Pointer Dereferencing - Documents how unsafe pointers are dereferenced into safe references, a key Rust safety pattern.
• Platform API Access - Provides opt-in submodules that expose native OS functionality through extension traits and types.
• Mutable to Const Pointer Casts - Defines how Rust casts between mutable and const raw pointers, a core unsafe operation.
• Raw Platform Metadata Access - Documents the raw platform metadata extension traits in Rust's standard library.
• Collection Capacity Reservation - Defines capacity reservation methods for collections in the standard library.
• Compiler Plugin Toolkits - Loads a compiler plugin via #plugin on an extern crate and passes optional meta arguments for configuration.
• C-Compatible String Conversions - Defines the safe C string creation API in Rust's standard library.
• Owned String-to-Box Slice Conversions - Defines the intoboxedstr method for converting Strings to boxed slices in Rust's standard library.
• Unconstrained Literal Warnings - Emits a lint warning when integer or floating-point literals lack explicit type constraints, helping developers enforce precise typing.
• Keyword Renaming Decisions - Changes a language keyword's spelling to improve clarity while preserving its reserved status and future use.
• Unprefixed Module Exports - Establishes naming conventions to avoid redundant module-name prefixes in exports.
• Thread Local Storage - Defines thread-local storage mechanisms including owned values with per-thread destructors.
• Scoped Key Cleanup - Implements scoped keys that automatically clean up thread-local storage on scope exit.
• Scoped Temporary Storage - Provides scoped thread-local storage that automatically restores previous values on scope exit.
• Procedural Macros - Registers procedural macros by calling methods on the plugin Registry with macro name and expansion logic.
• Pattern Macros - Expands macros inside match patterns so developers can reuse and abstract pattern logic across match arms.
• Unsafe Pointer Coercions - Specifies how Rust converts references to unsafe pointers, a fundamental language mechanism.
• Native Library Integrations - Points to pre-built native libraries on the system and passes custom linker flags using configuration files.
• External Library Linking - Passes arbitrary native library flags to the compiler through command-line arguments for dynamic or static linking.
• Binary and Octal Literal Lexing - Lexes binary and octal numeric literals using decimal digit rules, rejecting invalid digits at the lexer level.
• Panic Terminology Renamings - Renames the concept of task failure to task panic and the failure macro to panic macro for clearer terminology.
• Lifetime Anchoring from References - Documents how Rust anchors reference lifetimes to existing references when constructing from raw pointers.
• Non-Static Send Bounds - Specifies the removal of the implicit 'static bound from Send for broader lifetime compatibility.
• Custom Self Types - Allows methods to declare custom self types like a reference-counted pointer or garbage-collected pointer instead of only borrowed references.
• Format String Escaping Conventions - Specifies the escaping rules for format strings in the standard library's formatting macros.
• Regex Literal Escapers - Ships a standard library function to escape strings for literal use in regular expressions.
• Regular Expression Engines - Defines the standard library's regular expression engine with Unicode and word boundary support.
• Safe Memory Forgetting - Defines the safe forgetting of memory via mem::forget, a core Rust language capability.
• Context-Adaptive Display Adapters - Documents the pattern for creating context-adaptive Display implementations in the standard library.
• Box-to-String Conversions - Defines the conversion from Box to String in the standard library.
• Standard Input Processing - Defines the standard input stream access API in Rust's standard library.
• Wrapping Arithmetic Convenience Types - Uses a Wrapping newtype whose operators automatically wrap on overflow, simplifying code that needs wrapping semantics.
• Comparison Operator Chaining Rules - Removes implicit chaining of comparison operators so that chained comparisons must be written with explicit parentheses.
• Byte Literal Pattern Matching - Enables pattern matching on byte arrays using byte literal syntax in match expressions.
• Standard Library API Conventions - Captures the design conventions for Rust's standard library APIs documented in RFCs.
• Compile-Time Code Generation - Generates Rust source files during build using build scripts and the include! macro for compile-time code injection.
• C String Error Conversions - Provides automatic conversion of C string creation errors into standard I/O errors for ergonomic input handling.
• Standard Error Stream Handles - Defines the standard error stream access API in Rust's standard library.
• Box Pattern Feature Gates - Restricts the use of box patterns in match arms to only when the feature is explicitly enabled, preventing accidental reliance on unstable syntax.
• Symbolic Link Creations - Documents the platform-specific symlink creation API in Rust's standard library.
• Ring Buffer Slice Views - Defines the slice-based access API for Rust's ring buffer data structure.
• Macro-Driven Type Computations - Uses type macros to define recursive type-level operations like appending heterogeneous lists without manual trait boilerplate.
• Case-Insensitive Comparators - Provides standard library methods for ASCII case-insensitive string and byte slice comparison.
• Platform-Sensitive String Handlers - Creates and manipulates opaque strings that represent arbitrary platform-native data without loss.
• Split Operation Count Semantics - Defines the semantics of the count parameter in split operations for Rust APIs.
• Reference Construction from Raw Pointers - Specifies how Rust constructs references from raw pointers, a fundamental unsafe operation.
• Stream Read Error Types - Defines the UnexpectedEOF error type for incomplete stream reads in Rust's I/O library.
• Decision Records - Public RFC process for language-level design decisions.
• Rust internals - Listed in the “Rust internals” section of the Rust Learning awesome list.

Star-Verlauf