Crate std_macro_extensions

Source

Modules§

  • Atomic types
  • An ordered map based on a B-Tree.
  • An ordered set based on a B-Tree.
  • Constants associated with the current target
  • Owned and borrowed Unix-like file descriptors.
  • linuxLinux
    Linux-specific definitions.
  • Multi-producer, single-consumer FIFO queue communication primitives.
  • The I/O Prelude.
  • Compatibility module for C platform-specific types. Use core::ffi instead.
  • The 2015 version of the prelude of The Rust Standard Library.
  • The 2018 version of the prelude of The Rust Standard Library.
  • The 2021 version of the prelude of The Rust Standard Library.
  • The 2024 version of the prelude of The Rust Standard Library.
  • unixUnix
    Platform-specific extensions to std for Unix platforms.
  • The first version of the prelude of The Rust Standard Library.
  • A double-ended queue (deque) implemented with a growable ring buffer.
  • c_strExperimental
    CStr, CString, and related types.
  • mpmcExperimental
    Multi-producer, multi-consumer FIFO queue communication primitives.
  • os_strExperimental
    The OsStr and OsString types and associated utilities.
  • patternExperimental
    The string Pattern API.

Macros§

  • Creates a const raw pointer to a place, without creating an intermediate reference.
  • Creates a mut raw pointer to a place, without creating an intermediate reference.
  • Arc macro
  • A macro to create a new BTreeMap, providing two usage options:
  • Creates a new BTreeSet<T>.
  • Creates a new BinaryHeap<T>.
  • Creates a new Box instance.
  • Creates a new Cell instance.
  • Creates a new HashMap instance.
  • Creates a new HashSet instance.
  • Creates a new LinkedList instance.
  • Creates a new Mutex instance.
  • Expands to the offset in bytes of a field from the beginning of the given type.
  • Constructs a Pin<&mut T>, by pinning a value: T locally.
  • Creates a new Rc (Reference Counted) instance.
  • Extracts the successful type of a Poll<T>.
  • Creates a new RefCell instance.
  • Creates a new RwLock instance.
  • Creates a new String instance.
  • Creates a new Vec instance.
  • Creates a new VecDeque instance.
  • const_errorExperimental
    Creates a new I/O error from a known kind of error and a string literal.
  • joinExperimental
    Polls multiple futures simultaneously, returning a tuple of all results once complete.

Structs§

  • An error returned by LocalKey::try_with.
  • An error which can be returned when parsing an IP address or a socket address.
  • An iterator over Path and its ancestors.
  • A thread-safe reference-counting pointer. ‘Arc’ stands for ‘Atomically Reference Counted’.
  • An iterator over the arguments of a process, yielding a String value for each argument.
  • An iterator over the arguments of a process, yielding an OsString value for each argument.
  • This structure represents a safely precompiled version of a format string and its arguments. This cannot be generated at runtime because it cannot safely be done, so no constructors are given and the fields are private to prevent modification.
  • A simple wrapper around a type to assert that it is unwind safe.
  • An ordered map based on a B-Tree.
  • An ordered set based on a B-Tree.
  • A barrier enables multiple threads to synchronize the beginning of some computation.
  • A BarrierWaitResult is returned by Barrier::wait() when all threads in the Barrier have rendezvoused.
  • A priority queue implemented with a binary heap.
  • An error returned by RefCell::try_borrow.
  • An error returned by RefCell::try_borrow_mut.
  • A pointer type that uniquely owns a heap allocation of type T.
  • The BufReader<R> struct adds buffering to any reader.
  • Wraps a writer and buffers its output.
  • Used to create a default BuildHasher instance for types that implement Hasher and Default.
  • Thread factory, which can be used in order to configure the properties of a new thread.
  • Representation of a borrowed C string.
  • A type representing an owned, C-compatible, nul-terminated string with no nul bytes in the middle.
  • A mutable memory location.
  • An iterator over the chars of a string slice, and their positions.
  • The error type returned when a conversion from u32 to char fails.
  • An iterator over the chars of a string slice.
  • Representation of a running or exited child process.
  • A handle to a child process’s stderr.
  • A handle to a child process’s standard input (stdin).
  • A handle to a child process’s standard output (stdout).
  • An iterator over slice in (non-overlapping) chunks separated by a predicate.
  • An iterator over slice in (non-overlapping) mutable chunks separated by a predicate.
  • An iterator over a slice in (non-overlapping) chunks (chunk_size elements at a time), starting at the beginning of the slice.
  • An iterator over a slice in (non-overlapping) chunks (chunk_size elements at a time), starting at the beginning of the slice.
  • An iterator over a slice in (non-overlapping) mutable chunks (chunk_size elements at a time), starting at the beginning of the slice.
  • An iterator over a slice in (non-overlapping) mutable chunks (chunk_size elements at a time), starting at the beginning of the slice.
  • An iterator that clones the elements of an underlying iterator.
  • A process builder, providing fine-grained control over how a new process should be spawned.
  • An iterator over the command arguments.
  • An iterator over the command environment variables.
  • An iterator over the Components of a Path.
  • A Condition Variable
  • The context of an asynchronous task.
  • An iterator that copies the elements of an underlying iterator.
  • A Cursor wraps an in-memory buffer and provides it with a Seek implementation.
  • An iterator that repeats endlessly.
  • A struct to help with fmt::Debug implementations.
  • A struct to help with fmt::Debug implementations.
  • A struct to help with fmt::Debug implementations.
  • A struct to help with fmt::Debug implementations.
  • A struct to help with fmt::Debug implementations.
  • An iterator that decodes UTF-16 encoded code points from an iterator of u16s.
  • An error that can be returned when decoding UTF-16 code points.
  • The default Hasher used by RandomState.
  • A builder used to create directories in various manners.
  • Entries returned by the ReadDir iterator.
  • Opaque type representing the discriminant of an enum.
  • A Duration type to represent a span of time, typically used for system timeouts.
  • An iterator of u16 over the string encoded as UTF-16.
  • An iterator that yields the current count and the element during iteration.
  • An iterator over the escaped version of a byte slice.
  • This type represents the status code the current process can return to its parent under normal termination.
  • Describes the result of a process after it has terminated.
  • An object providing access to an open file on the filesystem.
  • Representation of the various timestamps on a file.
  • A structure representing a type of file with accessors for each file type. It is returned by Metadata::file_type method.
  • An iterator that filters the elements of iter with predicate.
  • An iterator that uses f to both filter and map elements from iter.
  • An iterator that maps each element to an iterator, and yields the elements of the produced iterators.
  • An iterator that flattens one level of nesting in an iterator of things that can be turned into iterators.
  • Configuration for formatting.
  • An error indicating that no nul byte was present.
  • An error indicating that a nul byte was not in the expected position.
  • A possible error value when converting a String from a UTF-8 byte vector.
  • A possible error value when converting a String from a UTF-16 byte slice.
  • An error indicating that a nul byte was not in the expected position.
  • An iterator that yields None forever after the underlying iterator yields None once.
  • A hash map implemented with quadratic probing and SIMD lookup.
  • A hash set implemented as a HashMap where the value is ().
  • An iterator that infinitely accepts connections on a TcpListener.
  • An iterator that calls a function with a reference to each element before yielding it.
  • A measurement of a monotonically nondecreasing clock. Opaque and useful only with Duration.
  • An error returned by BufWriter::into_inner which combines an error that happened while writing out the buffer, and the buffered writer object which may be used to recover from the condition.
  • An error indicating invalid UTF-8 when converting a CString into a String.
  • A buffer type used with Write::write_vectored.
  • A buffer type used with Read::read_vectored.
  • An IPv4 address.
  • An IPv6 address.
  • An owned permission to join on a thread (block on its termination).
  • The error type for operations on the PATH variable. Possibly returned from env::join_paths().
  • A value which is initialized on the first access.
  • A value which is initialized on the first access.
  • Wraps a writer and buffers output to it, flushing whenever a newline (0x0a, '\n') is detected.
  • LinesAnyDeprecated
    Created with the method lines_any.
  • A doubly-linked list with owned nodes.
  • A thread local storage (TLS) key which owns its contents.
  • A struct containing information about the location of a panic.
  • A wrapper to inhibit the compiler from automatically calling T’s destructor. This wrapper is 0-cost.
  • An iterator that maps the values of iter with f.
  • An iterator that only accepts elements while predicate returns Some(_).
  • Created with the method match_indices.
  • Created with the method matches.
  • Metadata information about a file.
  • A mutual exclusion primitive useful for protecting shared data
  • An RAII implementation of a “scoped lock” of a mutex. When this structure is dropped (falls out of scope), the lock will be unlocked.
  • *mut T but non-zero and covariant.
  • A value that is known not to equal zero.
  • An error indicating that an interior nul byte was found.
  • A cell which can nominally be written to only once.
  • A synchronization primitive which can nominally be written to only once.
  • State yielded to Once::call_once_force()’s closure parameter. The state can be used to query the poison status of the Once.
  • An iterator that yields a single element of type A by applying the provided closure F: FnOnce() -> A.
  • Options and flags which can be used to configure how a file is opened.
  • Borrowed reference to an OS string (see OsString).
  • A type that can represent owned, mutable platform-native strings, but is cheaply inter-convertible with Rust strings.
  • The output of a finished process.
  • A struct providing information about a panic.
  • An error returned when parsing a bool using from_str fails
  • An error which can be returned when parsing a char.
  • An error which can be returned when parsing a float.
  • An error which can be returned when parsing an integer.
  • A slice of a path (akin to str).
  • An owned, mutable path (akin to String).
  • An iterator with a peek() that returns an optional reference to the next element.
  • Creates a future which never resolves, representing a computation that never finishes.
  • Representation of the various permissions on a file.
  • A pointer which pins its pointee in place.
  • A type of error which can be returned whenever a lock is acquired.
  • A Future that wraps a function returning Poll.
  • A structure wrapping a Windows path prefix as well as its unparsed string representation.
  • An iterator over a slice in (non-overlapping) chunks (chunk_size elements at a time), starting at the end of the slice.
  • An iterator over a slice in (non-overlapping) chunks (chunk_size elements at a time), starting at the end of the slice.
  • An iterator over a slice in (non-overlapping) mutable chunks (chunk_size elements at a time), starting at the end of the slice.
  • An iterator over a slice in (non-overlapping) mutable chunks (chunk_size elements at a time), starting at the end of the slice.
  • Created with the method rmatch_indices.
  • Created with the method rmatches.
  • An iterator over the subslices of the vector which are separated by elements that match pred, starting from the end of the slice.
  • An iterator over subslices separated by elements that match a predicate function, limited to a given number of splits, starting from the end of the slice.
  • Created with the method rsplit_terminator.
  • RandomState is the default state for HashMap types.
  • A (half-open) range bounded inclusively below and exclusively above (start..end).
  • A range only bounded inclusively below (start..).
  • An unbounded range (..).
  • A range bounded inclusively below and above (start..=end).
  • A range only bounded exclusively above (..end).
  • A range only bounded inclusively above (..=end).
  • A RawWaker allows the implementor of a task executor to create a Waker or a LocalWaker which provides customized wakeup behavior.
  • A virtual function pointer table (vtable) that specifies the behavior of a RawWaker.
  • A single-threaded reference-counting pointer. ‘Rc’ stands for ‘Reference Counted’.
  • Iterator over the entries in a directory.
  • A future that is immediately ready with a value.
  • Wraps a borrowed reference to a value in a RefCell box. A wrapper type for an immutably borrowed value from a RefCell<T>.
  • A mutable memory location with dynamically checked borrow rules
  • A wrapper type for a mutably borrowed value from a RefCell<T>.
  • An iterator that repeats an element an exact number of times.
  • An iterator that repeats elements of type A endlessly by applying the provided closure F: FnMut() -> A.
  • A double-ended iterator with the direction inverted.
  • A helper struct for reverse ordering.
  • A reader-writer lock
  • RAII structure used to release the shared read access of a lock when dropped.
  • RAII structure used to release the exclusive write access of a lock when dropped.
  • Provides intentionally-saturating arithmetic on T.
  • An iterator to maintain state while iterating another iterator.
  • A scope to spawn scoped threads in.
  • An owned permission to join on a scoped thread (block on its termination).
  • A writer which will move data into the void.
  • SipHasherDeprecated
    An implementation of SipHash 2-4.
  • An iterator that skips over n elements of iter.
  • An iterator that rejects elements while predicate returns true.
  • An IPv4 socket address.
  • An IPv6 socket address.
  • A splicing iterator for Vec.
  • An iterator over the non-ASCII-whitespace substrings of a string, separated by any amount of ASCII whitespace.
  • An iterator over the mutable subslices of the vector which are separated by elements that match pred. Unlike SplitMut, it contains the matched parts in the ends of the subslices.
  • An iterator over the mutable subslices of the vector which are separated by elements that match pred.
  • An iterator over subslices separated by elements that match a predicate function, limited to a given number of splits.
  • An iterator that splits an environment variable into paths according to platform-specific conventions.
  • Created with the method split_terminator.
  • An iterator over the non-whitespace substrings of a string, separated by any amount of whitespace.
  • A handle to the standard error stream of a process.
  • A locked reference to the Stderr handle.
  • A handle to the standard input stream of a process.
  • A locked reference to the Stdin handle.
  • Describes what to do with a standard I/O stream for a child process when passed to the stdin, stdout, and stderr methods of Command.
  • A handle to the global standard output stream of the current process.
  • A locked reference to the Stdout handle.
  • An iterator for stepping iterators by a custom amount.
  • A UTF-8–encoded, growable string.
  • An error returned from Path::strip_prefix if the prefix was not found.
  • A new iterator where each successive item is computed based on the preceding one.
  • A measurement of the system clock, useful for talking to external entities like the file system or other processes.
  • An error returned from the duration_since and elapsed methods on SystemTime, used to learn how far in the opposite direction a system time lies.
  • An iterator that only accepts elements while predicate returns true.
  • A TCP socket server, listening for connections.
  • A TCP stream between a local and a remote socket.
  • A handle to a thread.
  • A unique identifier for a running thread.
  • Returns an iterator that yields the lowercase equivalent of a char.
  • Returns an iterator that yields the uppercase equivalent of a char.
  • The error type returned when a checked char conversion fails.
  • An error which can be returned when converting a floating-point value of seconds into a Duration.
  • The error type returned when a checked integral type conversion fails.
  • The error type returned when a conversion from a slice to an array fails.
  • The error type for try_reserve methods.
  • A TypeId represents a globally unique identifier for a type.
  • A UDP socket.
  • The core primitive for interior mutability in Rust.
  • An item returned by the Utf8Chunks iterator.
  • An iterator used to decode a slice of mostly UTF-8 bytes to string slices (&str) and byte slices (&[u8]).
  • Errors which can occur when attempting to interpret a sequence of u8 as a string.
  • An iterator over a snapshot of the environment variables of this process.
  • An iterator over a snapshot of the environment variables of this process.
  • A contiguous growable array type, written as Vec<T>, short for ‘vector’.
  • A double-ended queue implemented with a growable ring buffer.
  • A type indicating whether a timed wait on a condition variable returned due to a time out or not.
  • A Waker is a handle for waking up a task by notifying its executor that it is ready to be run.
  • An iterator over overlapping subslices of length size.
  • Provides intentionally-wrapped arithmetic on T.
  • Error returned for the buffered data from BufWriter::into_parts, when the underlying writer has previously panicked. Contains the (possibly partly written) buffered data.
  • An iterator that iterates two other iterators simultaneously.
  • ArrayChunksMutExperimental
    An iterator over a slice in (non-overlapping) mutable chunks (N elements at a time), starting at the beginning of the slice.
  • ArrayWindowsExperimental
    A windowed iterator over a slice in overlapping chunks (N elements at a time), starting at the beginning of the slice
  • AssumeExperimental
    Configurable proof assumptions of TransmuteFrom.
  • AsyncDropInPlaceExperimental
    A future returned by the async_drop_in_place.
  • BorrowedBufExperimental
    A borrowed byte buffer which is incrementally filled and initialized.
  • BorrowedCursorExperimental
    A writeable view of the unfilled portion of a BorrowedBuf.
  • ByRefSizedExperimental
    Like Iterator::by_ref, but requiring Sized so it can forward generics.
  • ContextBuilderExperimental
    A Builder used to construct a Context instance with support for LocalWaker.
  • DynMetadataExperimental
    The metadata for a Dyn = dyn SomeTrait trait object type.
  • ExclusiveExperimental
    Exclusive provides only mutable access, also referred to as exclusive access to the underlying value. It provides no immutable, or shared access to the underlying value.
  • ExitStatusErrorExperimental
    Describes the result of a process after it has failed
  • ExtractIfExperimental
    An iterator which uses a closure to determine if an element should be removed.
  • FormattingOptionsExperimental
    Options for formatting.
  • IntersperseExperimental
    An iterator adapter that places a separator between all elements.
  • IntersperseWithExperimental
    An iterator adapter that places a separator between all elements.
  • IntoIncomingExperimental
    An iterator that infinitely accepts connections on a TcpListener.
  • LocalWakerExperimental
    A LocalWaker is analogous to a Waker, but it does not implement Send or Sync.
  • MapWindowsExperimental
    An iterator over the mapped windows of another iterator.
  • MappedMutexGuardExperimental
    An RAII mutex guard returned by MutexGuard::map, which can point to a subfield of the protected data. When this structure is dropped (falls out of scope), the lock will be unlocked.
  • RAII structure used to release the shared read access of a lock when dropped, which can point to a subfield of the protected data.
  • RAII structure used to release the exclusive write access of a lock when dropped, which can point to a subfield of the protected data.
  • ReentrantLockExperimental
    A re-entrant mutual exclusion lock
  • ReentrantLockGuardExperimental
    An RAII implementation of a “scoped lock” of a re-entrant lock. When this structure is dropped (falls out of scope), the lock will be unlocked.
  • ReportExperimental
    An error reporter that prints an error and its sources.
  • RequestExperimental
    Request supports generic, type-driven access to data. Its use is currently restricted to the standard library in cases where trait authors wish to allow trait implementors to share generic information across trait boundaries. The motivating and prototypical use case is core::error::Error which would otherwise require a method per concrete type (eg. std::backtrace::Backtrace instance that implementors want to expose to users).
  • SyncUnsafeCellExperimental
  • ThinBoxExperimental
    ThinBox.
  • UniqueRcExperimental
    A uniquely owned Rc.
  • VaListExperimental
    A wrapper for a va_list
  • VaListImplExperimental
    x86_64 ABI implementation of a va_list.
  • YeetExperimental
    Implement FromResidual<Yeet<T>> on your type to enable do yeet expr syntax in functions returning your type.

Enums§

Constants§

Traits§

  • The addition operator +.
  • The addition assignment operator +=.
  • A trait to emulate dynamic typing.
  • Used to do a cheap mutable-to-mutable reference conversion.
  • Used to do a cheap reference-to-reference conversion.
  • AsciiExtDeprecated
    Extension methods for ASCII-subset only operations.
  • An async-aware version of the Fn trait.
  • An async-aware version of the FnMut trait.
  • An async-aware version of the FnOnce trait.
  • b formatting.
  • The bitwise AND operator &.
  • The bitwise AND assignment operator &=.
  • The bitwise OR operator |.
  • The bitwise OR assignment operator |=.
  • The bitwise XOR operator ^.
  • The bitwise XOR assignment operator ^=.
  • A trait for borrowing data.
  • A trait for mutably borrowing data.
  • A BufRead is a type of Reader which has an internal buffer, allowing it to perform extra ways of reading.
  • A trait for creating instances of Hasher.
  • ? formatting.
  • Used for immutable dereferencing operations, like *v.
  • Used for mutable dereferencing operations, like in *v = 1;.
  • The division operator /.
  • The division assignment operator /=.
  • An iterator able to yield elements from both ends.
  • Custom code within the destructor.
  • Trait for comparisons corresponding to equivalence relations.
  • An iterator that knows its exact length.
  • Extend a collection with the contents of an iterator.
  • The version of the call operator that takes an immutable receiver.
  • The version of the call operator that takes a mutable receiver.
  • The version of the call operator that takes a by-value receiver.
  • Used to do value-to-value conversions while consuming the input value. It is the reciprocal of Into.
  • Conversion from an Iterator.
  • Parse a value from a string
  • An iterator that always continues to yield None when exhausted.
  • A future represents an asynchronous computation obtained by use of async.
  • A hashable type.
  • A trait for hashing an arbitrary stream of bytes.
  • Used for indexing operations (container[index]) in immutable contexts.
  • Used for indexing operations (container[index]) in mutable contexts.
  • A value-to-value conversion that consumes the input value. The opposite of From.
  • Conversion into a Future.
  • Conversion into an Iterator.
  • Trait to determine if a descriptor/handle refers to a terminal/tty.
  • A trait for dealing with iterators.
  • e formatting.
  • x formatting.
  • The multiplication operator *.
  • The multiplication assignment operator *=.
  • The unary negation operator -.
  • The unary logical negation operator !.
  • o formatting.
  • Trait for types that form a total order.
  • Trait for comparisons using the equality operator.
  • Trait for types that form a partial order.
  • p formatting.
  • Trait to represent types that can be created by multiplying elements of an iterator.
  • RangeBounds is implemented by Rust’s built-in range types, produced by range syntax like .., a.., ..b, ..=c, d..e, or f..=g.
  • The Read trait allows for reading bytes from a source.
  • A marker trait representing types where a shared reference is considered unwind safe.
  • The remainder operator %.
  • The remainder assignment operator %=.
  • The Seek trait provides a cursor which can be moved within a stream of bytes.
  • The left shift operator <<. Note that because this trait is implemented for all integer types with multiple right-hand-side types, Rust’s type checker has special handling for _ << _, setting the result type for integer operations to the type of the left-hand-side operand. This means that though a << b and a.shl(b) are one and the same from an evaluation standpoint, they are different when it comes to type inference.
  • The left shift assignment operator <<=.
  • The right shift operator >>. Note that because this trait is implemented for all integer types with multiple right-hand-side types, Rust’s type checker has special handling for _ >> _, setting the result type for integer operations to the type of the left-hand-side operand. This means that though a >> b and a.shr(b) are one and the same from an evaluation standpoint, they are different when it comes to type inference.
  • The right shift assignment operator >>=.
  • A helper trait used for indexing operations.
  • The subtraction operator -.
  • The subtraction assignment operator -=.
  • Trait to represent types that can be created by summing up an iterator.
  • A trait for implementing arbitrary return types in the main function.
  • A generalization of Clone to borrowed data.
  • A trait for objects which can be converted or resolved to one or more SocketAddr values.
  • A trait for converting a value to a String.
  • Simple and safe type conversions that may fail in a controlled way under some circumstances. It is the reciprocal of TryInto.
  • An attempted conversion that consumes self, which may or may not be expensive.
  • A marker trait which represents “panic safe” types in Rust.
  • E formatting.
  • X formatting.
  • The implementation of waking a task on an executor.
  • AsyncDropExperimental
    Custom code within the asynchronous destructor.
  • CoerceUnsizedExperimental
    Trait that indicates that this is a pointer or a wrapper for one, where unsizing can be performed on the pointee.
  • ConcatExperimental
    Helper trait for [T]::concat.
  • CoroutineExperimental
    The trait implemented by builtin coroutine types.
  • DerefPureExperimental
    Perma-unstable marker trait. Indicates that the type has a well-behaved Deref (and, if applicable, DerefMut) implementation. This is relied on for soundness of deref patterns.
  • DispatchFromDynExperimental
    DispatchFromDyn is used in the implementation of dyn-compatibility checks (specifically allowing arbitrary self types), to guarantee that a method’s receiver type can be dispatched on.
  • FloatToIntExperimental
    Supporting trait for inherent methods of f32 and f64 such as to_int_unchecked. Typically doesn’t need to be used directly.
  • FromResidualExperimental
    Used to specify which residuals can be converted into which crate::ops::Try types.
  • JoinExperimental
    Helper trait for [T]::join
  • LocalWakeExperimental
    An analogous trait to Wake but used to construct a LocalWaker.
  • OneSidedRangeExperimental
    OneSidedRange is implemented for built-in range types that are unbounded on one side. For example, a.., ..b and ..=c implement OneSidedRange, but .., d..e, and f..=g do not.
  • PinCoerceUnsizedExperimental
    Trait that indicates that this is a pointer or a wrapper for one, where unsizing can be performed on the pointee when it is pinned.
  • PointeeExperimental
    Provides the pointer metadata type of any pointed-to type.
  • ReceiverExperimental
    Indicates that a struct can be used as a method receiver. That is, a type can use this type as a type of self, like this:
  • ResidualExperimental
    Allows retrieving the canonical type implementing Try that has this type as its residual and allows it to hold an O as its output.
  • StepExperimental
    Objects that have a notion of successor and predecessor operations.
  • TransmuteFromExperimental
    Marks that Src is transmutable into Self.
  • TrustedLenExperimental
    An iterator that reports an accurate length using size_hint.
  • TrustedStepExperimental
    A type that upholds all invariants of Step.
  • TryExperimental
    The ? operator and try {} blocks.
  • ZeroablePrimitiveExperimental
    A marker trait for primitive types which can be zero.

Functions§

  • Terminates the process in an abnormal fashion.
  • Makes the path absolute without accessing the filesystem.
  • Compares the addresses of the two pointers for equality, ignoring any metadata in fat pointers.
  • Returns the ABI-required minimum alignment of a type in bytes.
  • Returns the ABI-required minimum alignment of the type of the value that val points to in bytes.
  • Returns the arguments that this program was started with (normally passed via the command line).
  • Returns the arguments that this program was started with (normally passed via the command line).
  • Makes a soundness promise to the compiler that cond holds.
  • Returns an estimate of the default amount of parallelism a program should use.
  • An identity function that hints to the compiler to be maximally pessimistic about what black_box could do.
  • Returns the canonical, absolute form of a path with all intermediate components normalized and symbolic links resolved.
  • Invokes a closure, capturing the cause of an unwinding panic if one occurs.
  • Copies count * size_of::<T>() bytes from src to dst. The source and destination must not overlap.
  • Creates a new, empty directory at the provided path
  • Recursively create a directory and all of its parent components if they are missing.
  • Gets a handle to the thread that invokes it.
  • Returns the current working directory as a PathBuf.
  • Returns the full filesystem path of the current running executable.
  • Creates a new pointer that is dangling, but non-null and well-aligned.
  • Creates a new pointer that is dangling, but non-null and well-aligned.
  • Creates an iterator over the UTF-16 encoded code points in iter, returning unpaired surrogates as Errs. Use char::decode_utf16 instead.
  • Returns a value uniquely identifying the enum variant in v.
  • Disposes of a value.
  • Executes the destructor (if any) of the pointed-to value.
  • Compares raw pointers for equality.
  • Returns an iterator that produces an escaped version of a u8.
  • Returns Ok(true) if the path points at an existing entity.
  • Terminates the current process with the specified exit code.
  • Compares the addresses of the two function pointers for equality.
  • Takes ownership and “forgets” about the value without running its destructor.
  • Takes an Arguments struct and returns the resulting formatted string.
  • Converts a boxed slice of bytes to a boxed string slice without checking that the string contains valid UTF-8.
  • Converts a digit in the given radix to a char. Use char::from_digit instead.
  • Converts a u32 to a char. Use char::from_u32 instead.
  • Converts a u32 to a char, ignoring validity. Use char::from_u32_unchecked instead.
  • Converts a slice of bytes to a string slice.
  • Converts a mutable slice of bytes to a mutable string slice.
  • Converts a slice of bytes to a string slice without checking that the string contains valid UTF-8.
  • Converts a slice of bytes to a string slice without checking that the string contains valid UTF-8; mutable version.
  • Creates a new hard link on the filesystem.
  • Hash a raw pointer.
  • home_dirDeprecated
    Returns the path of the current user’s home directory if known.
  • Returns the OS-assigned process identifier associated with this process.
  • The identity function.
  • Determines whether the character is one of the permitted path separators for the current platform.
  • Joins a collection of Paths appropriately for the PATH environment variable.
  • Compares and returns the maximum of two values.
  • Returns the maximum of two values with respect to the specified comparison function.
  • Returns the element that gives the maximum value from the specified function.
  • Compares and returns the minimum of two values.
  • min_align_ofDeprecated
    Returns the ABI-required minimum alignment of a type in bytes.
  • Returns the ABI-required minimum alignment of the type of the value that val points to in bytes.
  • Returns the minimum of two values with respect to the specified comparison function.
  • Returns the element that gives the minimum value from the specified function.
  • Returns true if dropping values of type T matters.
  • Creates a null raw pointer.
  • Creates a null mutable raw pointer.
  • Creates an iterator that yields an element exactly once.
  • Creates an iterator that lazily generates a value exactly once by invoking the provided closure.
  • Panics the current thread with the given message as the panic payload.
  • Determines whether the current thread is unwinding because of panic.
  • Blocks unless or until the current thread’s token is made available.
  • Blocks unless or until the current thread’s token is made available or the specified duration has been reached (may wake spuriously).
  • park_timeout_msDeprecated
  • Creates a future which never resolves, representing a computation that never finishes.
  • Creates a future that wraps a function returning Poll.
  • Returns an iterator over the entries within a directory.
  • Reads a symbolic link, returning the file that the link points to.
  • Reads the value from src without moving it. This leaves the memory in src unchanged.
  • Performs a volatile read of the value from src without moving it. This leaves the memory in src unchanged.
  • Creates a future that is immediately ready with a value.
  • Removes an empty directory.
  • Removes a directory at this path, after removing all its contents. Use carefully!
  • Removes a file from the filesystem.
  • Removes an environment variable from the environment of the currently running process.
  • Renames a file or directory to a new name, replacing the original file if to already exists.
  • Creates a new iterator that repeats a single element a given number of times.
  • Creates a new iterator that repeats elements of type A endlessly by applying the provided closure, the repeater, F: FnMut() -> A.
  • Triggers a panic without invoking the panic hook.
  • Creates a scope for spawning scoped threads.
  • Changes the current working directory to the specified path.
  • Registers a custom panic hook, replacing the previously registered hook.
  • Changes the permissions found on a file or a directory.
  • Sets the environment variable key to the value value for the currently running process.
  • Creates an instance of a writer which will successfully consume all data.
  • Returns the size of a type in bytes.
  • Returns the size of the pointed-to value in bytes.
  • Puts the current thread to sleep for at least the specified amount of time.
  • sleep_msDeprecated
    Uses sleep.
  • Forms a raw slice from a pointer and a length.
  • Forms a raw mutable slice from a pointer and a length.
  • soft_linkDeprecated
    Creates a new symbolic link on the filesystem.
  • Spawns a new thread, returning a JoinHandle for it.
  • Emits a machine instruction to signal the processor that it is running in a busy-wait spin-loop (“spin lock”).
  • Parses input according to platform conventions for the PATH environment variable.
  • Constructs a new handle to the standard error of the current process.
  • Constructs a new handle to the standard input of the current process.
  • Constructs a new handle to the standard output of the current process.
  • Creates a new iterator where each successive item is computed based on the preceding one.
  • Swaps count * size_of::<T>() bytes between the two regions of memory beginning at x and y. The two regions must not overlap.
  • Queries the metadata about a file without following symlinks.
  • Replaces dest with the default value of T, returning the previous dest value.
  • Unregisters the current panic hook and returns it, registering the default hook in its place.
  • Returns the path of a temporary directory.
  • Reinterprets the bits of a value of one type as another type.
  • Interprets src as having type &Dst, and then reads src without moving the contained value.
  • Returns the name of a type as a string slice.
  • Returns the type name of the pointed-to value as a string slice.
  • uninitializedDeprecated
    Bypasses Rust’s normal memory-initialization checks by pretending to produce a value of type T, while doing nothing at all.
  • Informs the compiler that the site which is calling this function is not reachable, possibly enabling further optimizations.
  • Fetches the environment variable key from the current process.
  • Fetches the environment variable key from the current process, returning None if the variable isn’t set or if there is another error.
  • Returns an iterator of (variable, value) pairs of strings, for all the environment variables of the current process.
  • Returns an iterator of (variable, value) pairs of OS strings, for all the environment variables of the current process.
  • Converts an address back to a pointer, picking up some previously ‘exposed’ provenance.
  • Converts an address back to a mutable pointer, picking up some previously ‘exposed’ provenance.
  • Creates a pointer with the given address and no provenance.
  • Creates a pointer with the given address and no provenance.
  • Sets count * size_of::<T>() bytes of memory starting at dst to val.
  • Overwrites a memory location with the given value without reading or dropping the old value.
  • Performs a volatile write of a memory location with the given value without reading or dropping the old value.
  • Cooperatively gives up a timeslice to the OS scheduler.
  • Returns the value of type T represented by the all-zero byte-pattern.
  • Converts the arguments to iterators and zips them.
  • abort_unwindExperimental
    Invokes a closure, aborting if the closure unwinds.
  • add_spawn_hookExperimental
    Registers a function to run for every newly thread spawned.
  • align_of_val_rawExperimental
    Returns the ABI-required minimum alignment of the type of the value that val points to in bytes.
  • always_abortExperimental
    Makes all future panics abort directly without running the panic hook or unwinding.
  • async_dropExperimental
    Asynchronously drops a value by running AsyncDrop::async_drop on a value and its fields recursively.
  • async_drop_in_placeExperimental
    Creates the asynchronous destructor of the pointed-to value.
  • chainExperimental
    Converts the arguments to iterators and links them together, in a chain.
  • forget_unsizedExperimental
    Like forget, but also accepts unsized values.
  • from_coroutineExperimental
    Creates a new iterator where each iteration calls the provided coroutine.
  • from_mut_ptr_rangeExperimental
    Forms a mutable slice from a pointer range.
  • from_ptr_rangeExperimental
    Forms a slice from a pointer range.
  • Checks whether the standard library’s panic hook will capture and print a backtrace.
  • minmaxExperimental
    Compares and sorts two values, returning minimum and maximum.
  • minmax_byExperimental
    Returns minimum and maximum values with respect to the specified comparison function.
  • minmax_by_keyExperimental
    Returns minimum and maximum values with respect to the specified key function.
  • must_useExperimental
    An identity function that causes an unused_must_use warning to be triggered if the given value is not used (returned, stored in a variable, etc) by the caller.
  • rangeExperimental
    Performs bounds checking of a range.
  • request_refExperimental
    Requests a reference of type T from the given impl Error.
  • request_valueExperimental
    Requests a value of type T from the given impl Error.
  • Configures whether the default panic hook will capture and display a backtrace.
  • size_of_val_rawExperimental
    Returns the size of the pointed-to value in bytes.
  • sleep_untilExperimental
    Puts the current thread to sleep until the specified deadline has passed.
  • try_from_fnExperimental
    Creates an array [T; N] where each fallible array element T is returned by the cb call. Unlike from_fn, where the element creation can’t fail, this version will return an error if any element creation was unsuccessful.
  • try_rangeExperimental
    Performs bounds checking of a range without panicking.
  • update_hookExperimental
    Atomic combination of take_hook and set_hook. Use this to replace the panic handler with a new panic handler that does something and then executes the old handler.
  • variant_countExperimental
    Returns the number of variants in the enum type T.

Type Aliases§

Unions§

  • A wrapper type to construct uninitialized instances of T.

Derive Macros§

  • Derive macro generating an impl of the trait Debug.
  • Derive macro generating an impl of the trait Eq.
  • Derive macro generating an impl of the trait Hash.
  • Derive macro generating an impl of the trait Ord. The behavior of this macro is described in detail here.
  • Derive macro generating an impl of the trait PartialEq. The behavior of this macro is described in detail here.
  • Derive macro generating an impl of the trait PartialOrd. The behavior of this macro is described in detail here.