Module all

All the crate’s items re-exported flat.

---

Note that these items are already re-exported (hidden) from the root, as is every other public module’s contents from their parent.

Macros

• CONST
  A helper for constructing macro constants.
• addr_of
  core Create a const raw pointer to a place, without creating an intermediate reference.
• addr_of_mut
  core Create a mut raw pointer to a place, without creating an intermediate reference.
• array_init
  Initializes a [$T; $LEN] array in multiple ways.
• asm
  core Inline assembly.
• assert
  core Asserts that a boolean expression is true at runtime.
• assert_approx_eq_all
  Asserts the approximate equality of a series of expressions within tolerance.
• assert_eq
  core Asserts that two expressions are equal to each other.
• assert_eq_all
  Asserts the equality of a series of expressions.
• assert_ne
  core Asserts that two expressions are not equal to each other.
• bitfield_bit··
  Creates a custom bit field struct.
• capture_first
  Captures the first token from a list of inputs.
• capture_last
  Captures the last token from a list of inputs.
• capture_tail_tuple
  Captures all the tokens except the first one, as a tuple.
• cdbgstd
  customizable dbg! macro.
• cfg
  core Evaluates boolean combinations of configuration flags at compile-time.
• cfg_if
  A macro for defining #[cfg] if-else statements.
• cfor
  A for loop that is usable in compile-time contexts.
• cif
  devela_macros Evaluates to either a true of false literal based on the predicate.
• coalesce
  devela_macros Returns the first non-empty argument.
• code_column
  core Expands to the column number at which it was invoked.
• code_file
  core Expands to the file name at which it was invoked.
• code_line
  core Expands to the line number at which it was invoked.
• code_module
  core Expands to a string representing the current module path.
• compile_error
  core Causes compilation to fail with the given error message when encountered.
• concat
  core Concatenates literals into a static string slice.
• const_assert
  Asserts various comparisons on constants.
• const_bool
  Converts a const bool expression to a type-level boolean.
• cswap
  Swaps two mutable variables in a compile-time friendly manner.
• debug_assert
  core Asserts that a boolean expression is true at runtime.
• debug_assert_eq
  core Asserts that two expressions are equal to each other.
• debug_assert_ne
  core Asserts that two expressions are not equal to each other.
• deprecate_feature
  Configures a feature as deprecated, warning if it is enabled.
• detect_aarch64std and (AArch64 or target_arch="arm64ec")
  std Tests at runtime whether an aarch64 feature is enabled.
• detect_x86std and (x86 or x86-64)
  std Tests at runtime whether an x86/x86-64 feature is enabled.
• enumint
  devela_macros Generates a unit-only enum with variants associated to a specified range.
• enumset_bit_·
  Defines an enum and an associated type set of its variants.
• env_
  core Inspects an environment variable at compile time.
• field_of
  devela_macros Generates an expression for accessing a field of a tuple or struct.
• formatalloc
  alloc Creates a String using interpolation of runtime expressions.
• format_args
  core Constructs parameters for the other string-formatting macros.
• format_buf
  Returns a formatted str slice backed by a buffer, non-allocating.
• global_asm
  core Module-level inline assembly.
• id_seq
  A macro for constructing a unique sequential identifier generator.
• ident_const_index
  Defines a constant for every given identifier with a value of its index in the list.
• ident_total
  devela_macros Returns the total number of identifiers in its input.
• ident_total_unique
  devela_macros Returns the numbers of both total and unique identifiers in its input.
• ident_unique
  devela_macros Returns the number of unique identifiers in its input.
• iif
  inline if macro.
• impl_non_value
  Implements a NonValue[I|U]B<V>.
• impl_trait
  A helper macro to concisely implement a few common utility traits.
• include
  core Parses a file as an expression or an item according to the context.
• include_bytes
  core Includes a file as a reference to a byte array.
• include_from
  Includes a Rust source file relative to the project’s directory.
• include_str
  core Includes a UTF-8 encoded file as a string.
• items
  Groups items together and expands them as if they were written directly.
• mod_from
  Declares a module by including a Rust source file relative to the project’s directory.
• offset_of
  core Expands to the offset in bytes of a field from the beginning of the given type.
• option_env
  core Optionally inspects an environment variable at compile time.
• panic_
  core Panics the current thread.
• paste
  paste Allows to paste identifiers together.
• pin
  core Constructs a Pin<&mut T>, by pinning a value: T locally.
• sf
  skip formatting wrapper macro.
• size_of_expr
  Returns the size of an expression in bytes.
• sleep4std
  A more compact Thread::sleep.
• strdep_const_str
  &str compile-time operations, namespaced from the const-str crate.
• stringify
  core Stringifies its arguments.
• task_ready
  core Extracts the successful type of a TaskPoll<T>.
• thread_localstd
  std Declare a new thread local storage key of type ThreadLocalKey.
• todo
  core Indicates unfinished code.
• type_marker
  Defines zero-cost, zero-sized, generic marker IDs.
• type_resource
  Defines zero-cost, zero-sized, type-safe resource IDs.
• unimplemented
  core Indicates unimplemented code.
• unreachable
  core Indicates unreachable code.
• unwrap
  An unwrapper macro that works in compile-time.
• vec_alloc
  alloc Creates a Vec containing the arguments.
• write
  core Writes formatted data into a buffer.
• writeln
  core Writes formatted data into a buffer, with a newline appended.

Structs

• Alloc
  Memory-allocation-related operations.
• Anglegeom
  A generic angle.
• Arcalloc
  alloc A thread-safe reference-counting pointer.
• ArcWeakalloc
  alloc A version of Arc that holds a non-owning reference to the managed allocation.
• Arch
  Arch-related functionality.
• ArchivedArray
  An archived Array
• ArchivedArray2d
  An archived Array2d
• ArchivedBareBox
  An archived BareBox
• ArchivedBoxedalloc
  An archived Boxed
• ArchivedDestaque
  An archived Destaque
• ArchivedStack
  An archived Stack
• Array
  A static 1-dimensional array backed by the core array primitive.
• Array2d
  A static 2-dimensional Array.
• Array2dResolver
  The resolver for an archived Array2d
• ArrayFmt
  A formatting wrapper for core arrays, implementing Display and Debug.
• ArrayIntoIter
  🔄 core A by-value array iterator.
• ArrayResolver
  The resolver for an archived Array
• ArrayUninitunsafe_array
  A static array allowing uninitialized elements.
• Ascii
  Provides ASCII operations on T, most of them const.
• Atomicdep_atomic
  ⚛️ atomic A generic atomic wrapper type.
• AtomicBool
  ⚛️ ?core A boolean type which can be safely shared between threads.
• AtomicF32dep_portable_atomic
  ⚛️ portable-atomic A floating point type which can be safely shared between threads.
• AtomicF64dep_portable_atomic
  ⚛️ portable-atomic A floating point type which can be safely shared between threads.
• AtomicI8
  ⚛️ ?core A signed integer type which can be safely shared between threads.
• AtomicI16
  ⚛️ ?core A signed integer type which can be safely shared between threads.
• AtomicI32
  ⚛️ ?core A signed integer type which can be safely shared between threads.
• AtomicI64
  ⚛️ ?core A signed integer type which can be safely shared between threads.
• AtomicI128dep_portable_atomic
  ⚛️ portable-atomic A signed integer type which can be safely shared between threads.
• AtomicIsize
  ⚛️ ?core A signed integer type which can be safely shared between threads.
• AtomicPtr
  ⚛️ ?core A raw pointer type which can be safely shared between threads.
• AtomicU8
  ⚛️ ?core An unsigned integer type which can be safely shared between threads.
• AtomicU16
  ⚛️ ?core An unsigned integer type which can be safely shared between threads.
• AtomicU32
  ⚛️ ?core An unsigned integer type which can be safely shared between threads.
• AtomicU64
  ⚛️ ?core An unsigned integer type which can be safely shared between threads.
• AtomicU128dep_portable_atomic
  ⚛️ portable-atomic An unsigned integer type which can be safely shared between threads.
• AtomicUsize
  ⚛️ ?core An unsigned integer type which can be safely shared between threads.
• BTreeMapalloc
  alloc An ordered map based on a B-Tree.
• BTreeSetalloc
  alloc An ordered set based on a B-Tree.
• Backtracestd
  std A captured OS thread stack backtrace.
• BareBox
  A no-op pointer type, like a Box but without affecting how T is stored.
• BareBoxResolver
  The resolver for an archived BareBox
• Barrierstd
  std Enables multiple threads to synchronize the beginning of some computation.
• BarrierWaitResultstd
  std Returned by Barrier::wait() when all threads in the Barrier have rendezvoused.
• BinaryHeapalloc
  alloc A priority queue implemented with a binary heap.
• Bitwise_bit··
  Provides constant bitwise operations on T.
• Boxalloc
  alloc A pointer type that uniquely owns a heap allocation of type T.
• Boxedalloc
  A zero-sized marker for a Storage type that wraps its data in a Box.
• BoxedResolveralloc
  The resolver for an archived Boxed
• ByteSearch
  A utility struct for searching bytes in slices.
• CStr
  core Representation of a borrowed C string (See CString).
• CString
  alloc An owned, C-compatible, nul-terminated string with no nul bytes in the middle.
• CacheAlign
  Aligns and pads a value to the length of a cache line.
• Castprim···
  Provides const casting, joining and splitting operations between primitives.
• Cell
  core A mutable memory location.
• Char
  Unicode scalars-related operations.
• Colorcolor
  Color namespace for constants and methods
• Compare
  Provides comparing methods for T.
• Condvarstd
  std A Condition Variable
• ConstList
  An immutable, append-only, linear, functional, non-contiguous, list.
• ConstListIterator
  🔄 Iterates over the contents of a ConstList.
• Corounsafe_async
  Represents a single thread stackless coroutine.
• CoroRununsafe_async and alloc
  A managed dynamic collection of single-thread Coroutines.
• CoroYieldunsafe_async
  A future that alternates between Ready and Pending status each time it’s polled.
• DataOverflow
  🚩 The value has surpassed the bounds of the representable data space.
• DebugList
  core A struct to help with Debug implementations.
• DebugMap
  core A struct to help with Debug implementations.
• DebugSet
  core A struct to help with Debug implementations.
• DebugStruct
  core A struct to help with Debug implementations.
• DebugTuple
  core A struct to help with Debug implementations.
• Destaque
  A static double-ended queue and stack backed by an Array.
• DestaqueIter
  🔄 An iterator over Destaque elements.
• DestaqueResolver
  The resolver for an archived Destaque
• Discriminant
  core Opaque type representing the discriminant of an enum.
• Divisor
  Faster divisor for division and modulo operations.
• DstArrayunsafe_layout
  A static array for storing DSTs.
• DstQueueunsafe_layout
  A statically allocated FIFO queue of DSTs.
• DstQueueIterunsafe_layout
  🔄 An iterator over the elements of a DstQueue.
• DstQueueIterMutunsafe_layout
  🔄 A mutable iterator over the elements of a DstQueue.
• DstQueuePopHandleunsafe_layout
  Handle returned by DstQueue::pop (does the actual pop on drop).
• DstStackunsafe_layout
  A statically allocated LIFO stack of DSTs.
• DstStackIterunsafe_layout
  🔄 An iterator over the elements of a DstStack.
• DstStackIterMutunsafe_layout
  🔄 A mutable iterator over the elements of a DstStack.
• DstValueunsafe_layout
  A statically allocated DST value.
• Duration
  core A span of time, with u64 seconds and u32 nanoseconds.
• DurationErrorTryFromFloatSecs
  🚩 core Error returned from converting floating-point seconds into a Duration.
• ElementNotFound
  🚩 The requested element has not been found.
• Env
  A namespaced wrapper for std::env functions and constants.
• Extentgeom
  An orthogonal extension in D-space without a coordinate position.
• FailedErrorConversion
  🚩 A failed conversion between two error types.
• False
  A type-level logical false.
• FatPtr
  Represents a fat pointer with separate data and metadata pointers.
• Float
  Provides comprehensive floating-point operations for T, most of them const.
• FmtArguments
  core Represents a safely precompiled version of a format string and its arguments.
• FmtError
  🚩 core The error type which is returned from formatting a message into a stream.
• Formatter
  core Configuration for formatting.
• Frac
  Provides comprehensive fractional operations on T, most of them const.
• FuturePending
  core A future which never resolves, representing a computation that never finishes.
• FuturePollFn
  core A Future that wraps a function returning TaskPoll.
• FutureReady
  core A future that is immediately ready with a value.
• GcdReturn
  A return type for the calculated GCD and the Bézout coeficients.
• GraphemeNonul
  An EGC backed by a StringNonul.
• GraphemeStringalloc
  An EGC backed by a String.
• GraphemeU8
  An EGC backed by an StringU8.
• HashMapdep_hashbrown or std
  std? An unordered hash map implemented with quadratic probing and SIMD lookup.
• HashSetdep_hashbrown or std
  std? An unordered hash set implemented as a HashMap where the value is ()
• HasherBuildDefault
  core Create a default HasherBuild instance for T:Hasher+Default types.
• HasherFnvhash and cast
  A Fowler–Noll–Vo hasher.
• HasherFxhash
  This hashing algorithm was extracted from the Rustc compiler.
• HasherPengyhash
  A fast 64-bit non-cryptographic hash algorithm
• IdPin
  A unique identifier based on a pinned stack-allocated reference.
• IdPinBox
  A unique identifier based on a pinned heap-allocated memory address.
• IndexOutOfBounds
  🚩 The given index is out of bounds.
• Int
  Provides comprehensive integer operations on T, most of them const.
• Interval
  Represents an interval with a lower and an upper bound.
• InvalidAxisLength
  🚩 The given axis has an invalid length.
• InvalidChar
  🚩 An invalid given character was found.
• InvalidUtf8
  🚩 Invalid Utf-8 found while interpreting a byte sequence.
• IoBufReader
  ?std Adds buffering to any reader.
• IoBufWriter
  ?std Wraps a writer and buffers its output.
• IoBytes
  ?std An iterator over u8 values of a reader.
• IoChain
  ?std Adapter to chain together two readers.
• IoCursor
  ?std Wraps an in-memory buffer and provides it with a IoSeek implementation.
• IoError
  🚩+ ?std Error type for I/O operations of IoRead, IoWrite, IoSeek, and associated traits.
• IoLineWriter
  ?std Like BufWriter, but flushing whenever a newline (0x0a, ' ') is detected.
• IoLinesstd
  std An iterator over the lines of an instance of IoBufRead.
• IoSinkstd
  std A writer which will move data into the void.
• IoSlicestd
  std A buffer type used with IoWrite::write_vectored.
• IoSliceMutstd
  std A buffer type used with IoRead::read_vectored.
• IoSplitstd
  std An iterator over the contents of an instance of BufRead split on a particular byte.
• IoTake
  ?std Reader adapter which limits the bytes read from an underlying reader.
• IterChain
  🔄 core An iterator that links two iterators together, in a chain.
• IterChars
  🔄 core An iterator over the chars of a string slice.
• IterCloned
  🔄 core An iterator that clones the elements of an underlying iterator.
• IterCopied
  🔄 core An iterator that copies the elements of an underlying iterator.
• IterCycle
  🔄 core An iterator that repeats endlessly.
• IterEmpty
  🔄 core An iterator that yields nothing.
• IterEnumerate
  🔄 core An iterator that yields the current count and the element during iteration.
• IterFilter
  🔄 core An iterator that filters the elements of iter with predicate.
• IterFilterMap
  🔄 core An iterator that uses f to both filter and map elements from iter.
• IterFlatMap
  🔄 core An iterator that maps each element to an iterator, and yields their elements.
• IterFlatten
  🔄 core An iterator that flattens one level of nesting in an iterator of iterables.
• IterFromFn
  🔄 core An iterator where each iteration calls a closure F: FnMut() -> Option<T>.
• IterFuse
  🔄 core An iterator that yields None forever after the underlying yields None once.
• IterInspect
  🔄 core An iterator that calls a fn with a reference to each element before yielding it.
• IterMap
  🔄 core An iterator that maps the values of iter with f.
• IterMapWhile
  🔄 core An iterator that only accepts elements while predicate returns Some(_).
• IterOnce
  🔄 core An iterator that yields an element exactly once.
• IterOnceWith
  🔄 core An iterator that yields a single element A by calling F: FnOnce() -> A.
• IterPathstd
  std An iterator over the IterPathComponents of a Path, as OsStr slices.
• IterPathAncestorsstd
  🔄 std An iterator over Path and its ancestors.
• IterPathComponentsstd
  🔄 std An iterator over the Components of a Path.
• IterPeekable
  🔄 core An iterator with a peek() that returns an optional ref to the next element.
• IterRepeat
  🔄 core An iterator that repeats an element endlessly.
• IterRepeatWith
  🔄 core An iterator that endlessly repeats A by calling F: FnMut() -> A.
• IterRev
  🔄 core A double-ended iterator with the direction inverted.
• IterScan
  🔄 core An iterator to maintain state while iterating another iterator.
• IterSkip
  🔄 core An iterator that skips over n elements of iter.
• IterSkipWhile
  🔄 core An iterator that rejects elements while predicate returns true.
• IterStepBy
  🔄 core An iterator for stepping iterators by a custom amount.
• IterSuccessors
  🔄 core An iterator where each successive item is computed based on the preceding one.
• IterTake
  🔄 core An iterator that only iterates over the first n iterations of iter.
• IterTakeWhile
  🔄 core An iterator that only accepts elements while predicate returns true.
• IterZip
  🔄 core An iterator that iterates two other iterators simultaneously.
• KeyAlreadyExists
  🚩 The key already exists.
• LINUX_ERRNOlinux
  Linux sys/errno.h constants.
• LINUX_FILENOlinux
  Linux file descriptor constants.
• LINUX_IOCTLlinux
  Linux ioctl constants.
• LINUX_SIGACTIONlinux
  Linux flag constants for LinuxSigaction.
• LINUX_SIGNALlinux
  Linux standard signals constants.
• LINUX_SYS_AARCH64linux
  Linux sys/syscall.h constants for aarch64.
• LINUX_SYS_ARMlinux
  Linux sys/syscall.h constants for armv7.
• LINUX_SYS_RISCVlinux
  Linux sys/syscall.h constants for riscv.
• LINUX_SYS_X86linux
  Linux sys/syscall.h constants for x86.
• LINUX_SYS_X86_64linux
  Linux sys/syscall.h constants for x86_64.
• LINUX_TERMIOS_CFLAGlinux
  LinuxTermios control flags.
• LINUX_TERMIOS_IFLAGlinux
  LinuxTermios input flags.
• LINUX_TERMIOS_LFLAGlinux
  LinuxTermios local flags.
• LINUX_TERMIOS_OFLAGlinux
  LinuxTermios output flags.
• Layoutalloc
  alloc Layout of a block of memory.
• LayoutErroralloc
  alloc The parameters given to a Layout constructor did not satisfy the constraints.
• LazyCell
  core A value which is initialized on the first access.
• Lgc16rand
  A 16-bit LCG pseudo-random number generator.
• LinkedListalloc
  alloc A doubly-linked list with owned nodes.
• LinuxSigactionlinux
  Represents the sigaction structure from libc. Examine and change a signal action.
• LinuxSigsetlinux
  A set of signals.
• LinuxTerminalunsafe_syscall and linux
  Linux terminal manager.
• LinuxTerminalSizelinux
  The size of the terminal.
• LinuxTermioslinux
  Represents the termios structure from libc, used to control terminal I/O.
• LinuxTimespeclinux
  Represents the timespec structure from libc. Time in seconds and nanoseconds.
• ManuallyDrop
  core A wrapper to inhibit compiler from automatically calling T’s destructor.
• Mem
  Memory-related operations.
• Mismatch
  Represents a mismatch between an expected need and an encountered have.
• MismatchedCapacity
  🚩 The given capacity did not match the required constraints.
• MismatchedDimensions
  🚩 The dimensions given did not match the elements provided.
• MismatchedIndices
  🚩 The given indices does not match the expected order.
• Mutexstd
  std A mutual exclusion primitive useful for protecting shared data
• MutexGuardstd
  std An RAII implementation of a “scoped lock” of a mutex.
• NodeEmpty
  🚩 The node is empty.
• NodeLinkNotSet
  🚩 The link is not set.
• NodeLinkNotUnique
  🚩 The link is not unique.
• NonValueI8
  A signed integer that is known not to equal some specific value.
• NonValueU8
  An unsigned integer that is known not to equal some specific value.
• NonValueU16
  An unsigned integer that is known not to equal some specific value.
• NonZero
  core A value that is known not to equal zero.
• NotEnoughElements
  🚩 There are not enough elements for the operation.
• NotEnoughSpace
  🚩 There is not enough free space for the operation.
• NotImplemented
  🚩 The requested functionality is not implemented.
• NotSupported
  🚩 The requested functionality is not supported by this type.
• Oncestd
  std A synchronization primitive which can be used to run a one-time global initialization.
• OnceCell
  core A cell which can nominally be written to only once.
• OnceLockstd
  std A synchronization primitive which can be written to only once.
• OnceStatestd
  std State yielded to Once::call_once_force()’s closure parameter.
• OptionFmt
  The type returned from ExtOption::fmt_or_empty.
• OptionFmtOr
  The type returned from ExtOption::fmt_or.
• OptionFmtOrElse
  The type returned from ExtOption::fmt_or_else.
• OsStr
  std Borrowed reference to an OS string (See OsString).
• OsString
  std A type that can represent owned, mutable platform-native strings, but is cheaply inter-convertible with Rust strings.
• Own
  A return type encapsulating an owned state S and a value V.
• PanicAssertUnwindSafe
  core A simple wrapper around a type to assert that it is unwind safe.
• PanicInfo
  core A struct providing information about a panic.
• PanicLocation
  core A struct containing information about the location of a panic.
• ParseFloatError
  🚩 core An error which can be returned when parsing an float.
• ParseIntError
  🚩 core An error which can be returned when parsing an integer.
• PartiallyAdded
  🚩 The operation could only add a subset of the elements.
• Pathstd
  std A slice of a path (akin to str).
• PathBufstd
  std An owned, mutable path (akin to String).
• PathDisplaystd
  std Helper struct for safely printing paths with format! and {}.
• PathPrefixComponentstd
  std Wraps a Windows path prefix as well as its unparsed string representation.
• PathStripPrefixErrorstd
  🚩 std An error returned from Path::strip_prefix if the prefix was not found.
• PhantomData
  core Zero-sized type used to mark things that “act like” they own a T.
• PhantomPinned
  core A marker type which does not implement Unpin.
• Pin
  core A pointer which pins its pointee in place.
• Pinnedunsafe_ptr
  A wrapper for structurally pinned data.
• Pnmimage
  A collection of methods for encoding and decoding PNM bitmap formats.
• Pointgeom
  A coordinate position in D-space without extent.
• Pointsgeom
  A static sequence of N D-dimensional Points.
• PoisonErrorstd
  🚩 std A type of error which can be returned whenever a lock is acquired.
• Ptr
  Pointer-related operations.
• PtrNonNull
  core *mut T but non-zero and covariant.
• RandomStatestd
  std The default state for HashMapStd.
• Range
  core A range bounded inclusively below and exclusively above (start..end).
• RangeFrom
  core A range only bounded inclusively below (start..).
• RangeFull
  core An unbounded range (..).
• RangeInclusive
  core A range bounded inclusively below and above (start..=end).
• RangeTo
  core A range only bounded exclusively above (..end).
• RangeToInclusive
  core A range only bounded inclusively above (..=end).
• Rcalloc
  alloc A single-threaded reference-counting pointer.
• RcWeakalloc
  alloc A version of Rc that holds a non-owning reference to the managed allocation.
• Ref
  core A wrapper type for an inmutably borrowed value from a RefCell<T>
• RefCell
  core A mutable memory location with dynamically checked borrow rules.
• RefMut
  core A wrapper type for a mutably borrowed value from a RefCell<T>
• Reverse
  core A helper struct for reverse ordering.
• RwLockstd
  std A reader-writer lock
• RwLockReadGuardstd
  std RAII structure used to release the shared read access of a lock when dropped.
• RwLockWriteGuardstd
  std RAII structure used to release the exclusive write access of a lock when dropped.
• Saturating
  core Provides intentionally-saturating arithmetic on T.
• Slice
  Slice-related operations, most of them const.
• Sort
  Provides sorting methods for arrays and slices of T, some of them const.
• Stack
  A static stack backed by an Array.
• StackIter
  🔄 An iterator over Stack elements.
• StackResolver
  The resolver for an archived Stack
• Strstr
  A string slice namespace.
• Stringalloc
  alloc A UTF-8–encoded, growable string.
• StringNonul_string_nonul
  A UTF-8-encoded string, backed by an array with u8::MAX bytes of capacity. Can’t contain nul chars.
• StringU8_string_u8
  A UTF-8–encoded string, backed by an array with u8::MAX bytes of capacity.
• StringU16_string_u16
  A UTF-8–encoded string, backed by an array with u16::MAX bytes of capacity.
• StringU32_string_u32
  A UTF-8–encoded string, backed by an array with u32::MAX bytes of capacity.
• StringUsize_string_usize
  A UTF-8–encoded string, backed by an array with usize::MAX bytes of capacity.
• SystemInstantstd
  std A measurement of a monotonically nondecreasing clock.
• SystemTimestd
  std A measurement of the system clock.
• SystemTimeErrorstd
  🚩 An error returned from the duration_since and elapsed methods on SystemTime.
• TaskContext
  core The context of an asynchronous task.
• TaskRawWaker
  core Allows the implementor of a task executor to create a TaskWaker.
• TaskRawWakerVTable
  core A virtual function pointer table that specifies the behavior of a TaskRawWaker.
• TaskWaker
  core A handle for waking up a task by notifying its executor that it is ready to be run.
• Threadstd
  std A handle to a thread.
• ThreadAccessErrorstd
  std An error returned by ThreadLocalKey::try_with.
• ThreadBuilderstd
  std Thread factory, which can be used in order to configure the properties of a new thread.
• ThreadIdstd
  std A unique identifier for a running thread.
• ThreadJoinHandlestd
  std An owned permission to join on a thread (block on its termination).
• ThreadLocalKeystd
  std A thread local storage key which owns its contents.
• ThreadScopestd
  std A scope to spawn scoped threads in.
• ThreadScopedJoinHandlestd
  std An owned permission to join on a scoped thread (block on its termination).
• TimeSplittime
  A full time split from years to nanoseconds.
• Timecodetime
  Timecode splitting and formatting.
• True
  A type-level logical true.
• TryFromIntError
  🚩 core The error type returned when a checked integral type conversion fails.
• TupleFmt_tuple
  A formatting wrapper for Tuples, implementing Display and Debug.
• TupleIter_tuple
  🔄 An iterator over elements of a Tuple.
• TupleIterMut_tuple
  🔄 An iterator over exclusive references to elements of a Tuple.
• TupleIterRef_tuple
  🔄 An iterator over shared references to elements of a Tuple.
• TypeId
  core Represents a globally unique identifier for a type.
• TypeResource
  A newtype-based ID that associates a resource with its inner ID.
• UnixTimeI64time
  64-bit Unix time, supporting negative values.
• UnixTimeU32time
  32-bit Unix time, supporting only non-negative values.
• UnsafeCell
  core The core primitive for interior mutability in Rust.
• ValueQuant
  A value with associated quantification.
• Vecalloc
  alloc A contiguous growable array.
• VecDequealloc
  alloc A double-ended growable queue.
• VecPointsgeom and alloc
  A dynamic sequence of D-dimensional Points.
• VecVectoralg and alloc
  A dynamic vector, backed by a primitive Vec.
• Vectoralg
  A static D-dimensional vector, backed by a primitive array.
• WaitTimeoutResultstd
  std A type indicating whether a timed wait on a condition variable returned due to a time out or not.
• WaveletHaarwave
  A Haar wavelet is a simple, piecewise-constant wavelet.
• WaveletUnitVecalloc and wave
  A single unit of the wavelet decomposition at a specific level and position.
• Wrapping
  core Provides intentionally-wrapped arithmetic on T.
• Xabcrand
  X ABC Algorithm Random Number Generator for 8-bit Devices.
• XorShift8rand
  The XorShift8 pseudo-random number generator.
• XorShift8Customrand
  A version of XorShift8 that allows customizing the shift values.
• XorShift16rand
  The XorShift16 pseudo-random number generator.
• XorShift32rand
  The XorShift32 pseudo-random number generator.
• XorShift64rand
  The XorShift64 pseudo-random number generator.
• XorShift128rand
  The XorShift128 pseudo-random number generator.
• XorShift128prand
  The XorShift128+ pseudo-random number generator.
• Xoroshiro128pprand
  The Xoroshiro128++ pseudo-random number generator.
• Xyza8arand
  A simple 8-bit pseudo-random number generator with 32-bit of state, based on the XorShift algorithm.
• Xyza8brand
  A simple 8-bit pseudo-random number generator with 32-bit of state, based on the XorShift algorithm.
• char7_char7
  A 7-bit unicode scalar, limited to basic latin subset (ASCII).
• char8_char8
  An 8-bit unicode scalar, limited to basic latin and latin-1 subsets.
• char16_char16
  A 16-bit unicode scalar, limited to the Basic Multilingual Plane subset.
• m128dep_safe_arch
  safe_arch The data for a 128-bit SSE register of four f32 lanes.
• m256dep_safe_arch
  safe_arch The data for a 256-bit AVX register of eight f32 lanes.
• m128ddep_safe_arch
  safe_arch The data for a 128-bit SSE register of two f64 values.
• m128idep_safe_arch
  safe_arch The data for a 128-bit SSE register of integer data.
• m256ddep_safe_arch
  safe_arch The data for a 256-bit AVX register of four f64 values.
• m256idep_safe_arch
  safe_arch The data for a 256-bit AVX register of integer data.

Enums

• AngleDirectiongeom
  The angle direction.
• AngleKindgeom
  The angle kind, based on its normalized magnitude.
• AsciiCharascii
  One of the 128 Unicode characters from U+0000 through U+007F, often known as the ASCII subset.
• AtomicOrdering
  core Atomic memory ordering.
• AudioErroraudio
  🚩+ An audio-related error.
• BTreeMapEntryalloc
  alloc An ordered map based on a B-Tree.
• BacktraceStatusstd
  std The current status of a backtrace.
• Bound
  core An endpoint of a range of keys.
• ColorErrorcolor
  🚩+ A color-related error.
• CompressionMode
  The type of compression applied to data.
• ControlFlow
  core Used to tell an operation whether it should exit early or go on as usual.
• Cowalloc
  alloc A clone-on-write smart pointer.
• DataNotEnough
  🚩+ An error composite of NotEnoughElements + NotEnoughSpace.
• DrawErrordraw
  🚩+ A drawing-related error.
• EncodingMode
  The primary mode for data encoding.
• FloatCategory
  core A classification of floating point numbers.
• FmtAlignment
  core Possible alignments returned by Formatter::align.
• FontErrorfont
  🚩+ A font-related error.
• HashMapEntrydep_hashbrown or std
  std? A view into a single entry in a map, which may either be vacant or occupied.
• ImageErrorimage
  🚩+ An image-related error.
• Infallible
  🚩 core The error type for errors that can never happen.
• InvalidText
  🚩+ An error composite of InvalidChar + InvalidUtf8 + MismatchedCapacity.
• IoErrorKind
  🚩+ ?std A list specifying general categories of I/O error.
• LayoutErrorlayout
  🚩+ A layout-related error.
• MediaErrormedia··
  🚩+ A media-related error.
• MidiErrormidi
  🚩+ A midi-related error.
• MismatchedBounds
  🚩+ An error composite of DataOverflow + IndexOutOfBounds + MismatchedIndices + MismatchedCapacity.
• Month
  The months of the year.
• NotAvailable
  🚩+ An error composite of NotImplemented + NotSupported.
• NumError
  🚩+ A numeric-related error.
• Ordering
  core The result of a comparison between two values.
• ParseIntErrorKind
  🚩+ core Kinds of errors that can cause parsing an integer to fail.
• PartialSpace
  🚩+ An error composite of NotEnoughSpace + PartiallyAdded.
• PathComponentstd
  std A single component of a path.
• PathPrefixstd
  std Windows path prefixes, e.g., C: or \\server\share.
• Result
  ⚖️ core A type that represents either success (Ok) or failure (Err).
• Sign
  Represents the sign of a number.
• TaskPoll
  core Indicates whether a value is ready or if the current task is still pending.
• TryLockErrorstd
  🚩+ std An enumeration of possible errors associated with a TryLockResult.
• TupleElement_tuple
  An element of a Tuple.
• TupleElementMut_tuple
  An exclusive reference to an element of a Tuple.
• TupleElementRef_tuple
  A shared reference to an element of a Tuple.
• UiErrorui··
  A user-interface error.
• UnitBiunit
  Binary unit prefixes.
• UnitSiunit
  SI (metric) unit prefixes.
• VecChunkalloc
  A persistent data structure that provides efficient append and concatenation operations.
• WaveletUnitRolewave
  Distinguishes the role of a component in wavelet analysis.
• Weekday
  The days of the week.
• c_void
  ⚙️ core Equivalent to the corresponding C type.
• CoroutineStateExperimentalnightly_coro
  core The result of a coroutine resumption.

Constants

• UNIX_EPOCHstd
  std A SystemTime anchored to “1970-01-01 00:00:00 UTC”.

Statics

• LINUX_TERMINAL_STATEunsafe_syscall and linux and dep_atomic and dep_bytemuck
  State of the terminal saved globally, that can be restored from anywhere.

Traits

• Add
  core The addition operator +.
• AddAssign
  core The addition assignment operator +=.
• Any
  core A trait to emulate dynamic typing.
• AsMut
  core Used to do a cheap mutable-to-mutable reference conversion.
• AsRef
  core Used to do a cheap reference-to-reference conversion.
• Binary
  core b formatting.
• BitAnd
  core The bitwise AND operator &.
• BitAndAssign
  core The bitwise AND assignment operator &=.
• BitOps
  Provides bitwise operations on T.
• BitOr
  core The bitwise OR operator |.
• BitOrAssign
  core The bitwise OR assignment operator |=.
• BitSized
  Type size information in bits.
• BitXor
  core The bitwise XOR operator ^.
• BitXorAssign
  core The bitwise XOR assignment operator ^=.
• Borrow
  core A trait for borrowing data.
• BorrowMut
  core A trait for mutably borrowing data.
• ByteSized
  Type size information in bytes.
• Chain
  Allows chaining transformations by passing values through a sequence of functions.
• Clone
  core A common trait for the ability to explicitly duplicate an object.
• ColorBasecolor
  Base trait for general color data representation.
• ConstBool
  Allows to convert compile-time constants into type-level booleans.
• ConstDefault
  A trait for giving a type a useful default value in compile-time.
• Copy
  core Types whose values can be duplicated simply by copying bits.
• DataArray
  An abstract array data type.
• DataCollection
  An abstract collection data type.
• DataDeque
  An abstract double-ended queue data type.
• DataDesta
  An abstract double-ended stack data type.
• DataQueue
  An abstract queue data type.
• DataStack
  An abstract stack data type.
• Debug
  core ? formatting.
• Default
  core A trait for giving a type a useful default value.
• Deref
  core Used for immutable dereferencing operations, like *v.
• DerefMut
  core Used for mutable dereferencing operations, like in *v = 1;.
• Display
  core Format trait for an empty format, {}.
• Div
  core The division operator /.
• DivAssign
  core The division assignment operator /=.
• Drop
  core Custom code within the destructor.
• DstBufunsafe_layout
  Represents the backing buffer for storing dynamically sized types.
• Eq
  core Trait for comparisons corresponding to equivalence relations.
• Error
  core A trait representing the basic expectations for error values.
• ExtAny
  Extension trait providing convenience methods for T:Any.
• ExtArray
  Extension trait providing convenience methods for [T; N] arrays.
• ExtCellOption
  A trait that provides additional methods for Cell<Option>.
• ExtError
  Extension trait providing additional methods for T:Error.
• ExtFloat
  Extension trait for floating-point types. Associated methods.
• ExtFloatConst
  Extension trait for floating-point types. Associated constants.
• ExtFuture
  Extension trait providing additional methods for Futures.
• ExtMem
  Extension trait for type memory information and manipulation.
• ExtOptRes
  Extension trait providing additional methods for OptRes.
• ExtOption
  Extension trait providing additional methods for Option.
• ExtPathstd
  Extension trait providing additional methods for paths.
• ExtResult
  Extension trait providing additional methods for Result.
• ExtSlice
  Extension trait providing additional methods for &[T].
• ExtSliceMut
  Extension trait providing additional methods for &mut [T].
• ExtStrstr
  Extension trait providing additional methods for &str.
• ExtStringstr and alloc
  Extension trait providing additional methods for String.
• ExtThread
  Extension trait providing additional methods for Threads.
• ExtVecalloc
  Extension trait providing additional methods for Vec.
• Fn
  core The version of the call operator that takes an immutable receiver.
• FnMut
  core The version of the call operator that takes a mutable receiver.
• FnOnce
  core The version of the call operator that takes a by-value receiver.
• From
  core Used to do value-to-value conversions while consuming the input value.
• FromStr
  core Parse a value from a string.
• Future
  core An asynchronous computation obtained by use of async.
• GlobalAllocalloc
  alloc
• Grapheme
  Common trait for EGC types.
• Hash
  core A hashable type.
• Hasher
  core A trait for hashing an arbitrary stream of bytes.
• HasherBuild
  core A trait for creating instances of Hasher.
• Hook
  Allows attaching operations or side effects to a value without breaking its flow.
• Index
  core Used for indexing operations (container[index]) in immutable contexts.
• IndexMut
  core Used for indexing operations (container[index]) in mutable contexts.
• Into
  core A value-to-value conversion that consumes the input value.
• IntoFuture
  core Conversion into a Future.
• IoBufRead
  ?std A type of Reader which has an internal buffer.
• IoRead
  ?std Allows for reading bytes from a source.
• IoSeek
  ?std Provides a cursor which can be moved within a stream of bytes.
• IoWrite
  ?std A trait for objects which are byte-oriented sinks.
• Iterator
  core A trait for dealing with iterators.
• IteratorDoubleEnded
  core An iterator able to yield elements from both ends.
• IteratorExactSize
  core An iterator that knows its exact length.
• IteratorExtend
  core Extend a collection with the contents of an iterator.
• IteratorFrom
  core Conversion from an Iterator.
• IteratorFused
  core An iterator that always continues to yield None when exhausted.
• IteratorInto
  core Conversion into an Iterator.
• IteratorProduct
  core Represents types that can be created by multiplying elements of an iterator.
• IteratorSum
  core Represents types that can be created by summing up an iterator.
• LowerExp
  core e formatting.
• LowerHex
  core x formatting.
• MemAligned
  Marker trait to verify memory alignment between two types.
• MemPodunsafe_layout
  Indicates a type is Plain Old Data, and meets specific memory layout guarantees.
• Mul
  core The multiplication operator *.
• MulAssign
  core The multiplication assignment operator *=.
• Neg
  core The unary negation operator -.
• Not
  core The unary logical negation operator !.
• Num
  Common trait for numeric types.
• NumInt
  Common trait for integer types.
• NumRef
  Common auto-trait for referenced numeric types.
• NumRefInt
  Common auto-trait for referenced integer types.
• NumToStrfmt
  Converts a number into a string representation, storing it into a byte slice.
• NumVectoralg
  A common trait for all vectors.
• Octal
  core o formatting.
• Ord
  core Trait for types that form a total order.
• PanicRefUnwindSafe
  core A marker trait which represents a shared reference considered unwind safe.
• PanicUnwindSafe
  core A marker trait which represents “panic safe” types in Rust.
• PartialEq
  core Trait for comparisons using the equality operator.
• PartialOrd
  core Trait for types that form a partial order.
• Pointer
  core p formatting.
• PrimitiveCastcast
  Offers methods for casting between primitives.
• PrimitiveJoinjoin
  Offers methods to construct a primitive from an array or slice of smaller primitives.
• PrimitiveSplitsplit
  Offers methods to split a primitive into an array of smaller primitives.
• RangeBounds
  core Implemented by Rust’s built-in range types
• Rem
  core The remainder operator %.
• RemAssign
  core The remainder assignment operator %=.
• Send
  core Types that can be transferred across thread boundaries.
• Sized
  core Types with a constant size known at compile time.
• Storage
  Allows to be generic in respect of the data storage.
• Sub
  core The subtraction operator -.
• SubAssign
  core The subtraction assignment operator -=.
• Sync
  core Types for which it is safe to share references between threads.
• TaskWakealloc
  alloc The implementation of waking a task on an executor.
• TextWrite
  core Writing or formatting into Unicode-accepting buffers or streams.
• ToOwnedalloc
  alloc A generalization of Clone to borrowed data.
• ToStringalloc
  alloc A trait for converting a value to a String.
• TryFrom
  core Simple and safe type conversions that may fail in a controlled way.
• TryInto
  core An attempted conversion that consumes self, which may or may not be expensive.
• Tuple_tuple
  Extension trait providing convenience methods for tuples.
• TypeResourced
  Represents an association between a resource and its inner data type.
• UnicodeScalar
  Common trait for unicode scalar types.
• Unitunit
  Unit prefixes.
• Unpin
  core Types that do not require any pinning guarantees.
• UpperExp
  core E formatting.
• UpperHex
  core X formatting.
• WaveletCompressionVecalloc and wave
  Trait for lossy compression of wavelet coefficients.
• WaveletTransformVecalloc and wave
  Trait defining essential wavelet transform operations.
• CoroutineExperimentalnightly_coro
  core The trait implemented by builtin coroutine types.

Functions

• array_from_fn
  core Creates an array [T; N], where each T is returned from cb from its index.
• array_from_mut
  core Converts a mutable reference to T into &mut [T; 1] (without copying).
• array_from_ref
  core Converts a reference to T into &[T; 1] (without copying).
• assert_unchecked^⚠
  core Makes a soundness promise to the compiler that the condition holds.
• atomic_compiler_fence
  core A compiler memory fence.
• atomic_fence
  core An atomic fence.
• black_box
  core Hints the compiler to be maximally pessimistic about what black_box could do.
• bytes_from_bits
  Returns the rounded up size in bytes from a size in bits.
• crate_rootstd
  Returns an absolute PathBuf, relative to the crate’s root.
• crate_root_stringstd
  Like crate_root but returns a String.
• fmt_formatalloc
  alloc Takes an FmtArguments struct and returns the resulting formatted string.
• fmt_write
  core Takes an output stream, and an FmtArguments struct.
• format_buf_args
  Returns a formatted str slice backed by a buffer, non-allocating.
• future_blockstd
  Blocks the thread until the future is ready.
• future_pending
  core Creates a FuturePending future.
• future_ready
  core Creates a FutureReady.
• identity
  core The identity function. Just returns back its input.
• io_copy
  ?std Copies the entire contents of a reader into a writer.
• io_emptystd
  std Creates a value that is always at EOF for reads, and ignores all data written.
• io_read_to_stringstd
  std Read all bytes from a reader into a new String
• io_repeatstd
  std Creates an instance of a reader that infinitely repeats one byte.
• io_sinkstd
  std Creates an instance of a writer which will successfully consume all data.
• io_stderrstd
  std Constructs a new handle to the standard error of the current process.
• io_stdinstd
  std Constructs a new handle to the standard input of the current process.
• io_stdoutstd
  std Constructs a new handle to the standard output of the current process.
• is_leap_yeartime
  Returns true if the provided year is a leap year.
• iter_empty
  core Creates an iterator that yields nothing.
• iter_from_fn
  core Creates an iterator that calls the given closure F: FnMut() -> Option<T>.
• iter_once
  core Creates an iterator that yields an element exactly once.
• iter_once_with
  core Creates an iterator that lazily generates a value exactly once.
• iter_repeat
  core Creates an iterator that endlessly repeats a single element.
• iter_repeat_with
  core Creates an iterator that endlessly repeats calling F: FnMut() -> A.
• iter_successors
  core Creates an iterator where each successive item is computed based on the previous.
• iter_zip
  core Converts the arguments to iterators and zips them.
• linux_eprintunsafe_syscall and linux
  Prints a string slice to standard error.
• linux_eprintlnunsafe_syscall and linux
  Prints a string slice to standard error, with a newline.
• linux_get_byteunsafe_syscall and linux
  Gets a single byte from stdin.
• linux_get_charunsafe_syscall and linux
  Gets a single char from stdin, or None if the bytes are not valid utf-8.
• linux_get_dirty_charunsafe_syscall and linux
  Gets either a single char from stdin, or the replacement character.
• linux_get_lineunsafe_syscall and linux
  Gets a string from stdin backed by a buffer, until a newline.
• linux_get_strunsafe_syscall and linux
  Gets a string from stdin backed by a buffer, until the stop char is received.
• linux_get_utf8_bytesunsafe_syscall and linux
  Gets a utf-8 encoded byte sequence from stdin representing a char.
• linux_getpidunsafe_syscall and linux
  Returns the current process number.
• linux_pause_until_charunsafe_syscall and linux
  Pauses execution until receiving from stdin any char in the list.
• linux_printunsafe_syscall and linux
  Prints a string slice to standard output.
• linux_print_bytesunsafe_syscall and linux
  Prints a byte slice to stdout.
• linux_printlnunsafe_syscall and linux
  Prints a string slice to standard output, with a newline.
• linux_promptunsafe_syscall and linux
  Prompts the user for a string from stdin, backed by a buffer.
• linux_random_bytesunsafe_syscall and linux
  Fills the given buffer with random bytes that may not be cryptographically secure.
• linux_random_u8unsafe_syscall and linux
  Generates a random u8 value that may not be criptographically secure.
• linux_random_u16unsafe_syscall and linux
  Generates a random u16 value that may not be criptographically secure.
• linux_random_u32unsafe_syscall and linux
  Generates a random u32 value that may not be criptographically secure.
• linux_random_u64unsafe_syscall and linux
  Generates a random u64 value that may not be criptographically secure.
• linux_random_u128unsafe_syscall and linux
  Generates a random u128 value that may not be criptographically secure.
• linux_sig_handler_no_returnunsafe_syscall and linux
  Registers multiple signals using a handler function that never returns.
• linux_sleepunsafe_syscall and linux
  Suspends execution of calling thread for duration.
• linux_sys_exit^⚠unsafe_syscall and linux
  Performs an exit syscall.
• linux_sys_getpid^⚠unsafe_syscall and linux
  Performs a getpid syscall.
• linux_sys_getrandom^⚠unsafe_syscall and linux
  Performs a getrandom syscall.
• linux_sys_ioctl^⚠unsafe_syscall and linux
  Performs an ioctl syscall.
• linux_sys_nanosleep^⚠unsafe_syscall and linux
  Performs a nanosleep syscall.
• linux_sys_read^⚠unsafe_syscall and linux
  Performs a read syscall.
• linux_sys_rt_sigaction^⚠unsafe_syscall and linux
  Performs an rt_sigaction syscall.
• linux_sys_write^⚠unsafe_syscall and linux
  Performs a write syscall.
• panic_anystd
  std Panic the current thread with the given message as the panic payload.
• panic_catchstd
  std Invokes a closure, capturing the cause of an unwinding panic if one occurs.
• panic_resumestd
  std Triggers a panic without invoking the panic hook.
• panic_set_hookstd
  std Registers a custom panic hook, replacing the previously registered hook.
• panic_unset_hookstd
  std Unregisters the current panic hook, returns it and registers the default hook in its place.
• prime_number_theoremstd or _float_f64
  The prime number theorem formula.
• serr
  Wraps the given OptRes value in a Some(Err(error)).
• sok
  Wraps the given OptRes value in a Some(Ok(value)).
• spin_loop
  core Signals the processor that it is running in a busy-wait spin-loop.
• task_waker_noopunsafe_async
  Creates a new Waker that does nothing when wake is called.
• transmute^⚠Deprecated
  core Reinterprets the bits of a value of one type as another type.
• unreachable_unchecked^⚠
  core Informs the compiler that the current calling site is not reachable.
• iter_from_coroutineExperimentalnightly_coro
  core Creates an iterator where each iteration calls the provided coroutine.

Type Aliases

• AudioResultaudio
  ⚖️ An audio-related result.
• Bare
  core A zero-sized marker for a Storage type that wraps its data in a BareBox.
• ColorResultcolor
  ⚖️ A color-related result.
• DestaqueU8_destaque_u8
  A Destaque with an 8-bit index size.
• DestaqueU16_destaque_u16
  A Destaque with a 16-bit index size.
• DestaqueU32_destaque_u32
  A Destaque with a 32-bit index size.
• DestaqueUsize_destaque_usize
  A Destaque with a pointer-sized index size.
• DrawResultdraw
  ⚖️ A drawing-related result.
• DstArrayUsizeunsafe_layout
  A statically allocated buffer for storing DSTs with pointer alignment.
• DstQueueUsizeunsafe_layout
  A statically allocated FIFO queue of DSTs with pointer alignment.
• DstStackUsizeunsafe_layout
  A statically allocated LIFO stack of DSTs with pointer alignment.
• DstValueUsizeunsafe_layout
  A statically allocated DST value with pointer alignment.
• DstVecUsizeunsafe_layout and alloc
  A dynamically allocated buffer for storing DSTs with pointer alignment.
• Extent2dgeom
  A 2-dimensional Extent.
• Extent3dgeom
  A 3-dimensional Extent.
• FmtResult
  ⚖️ The type returned by formatter methods.
• FontResultfont
  ⚖️ A font-related result.
• HashMapFxhash and (std, or dep_hashbrown and hash)
  A HashMap using a default Fx hasher.
• HashMapStdstd
  The HashMap in the standard library.
• HashSetFxhash and (std, or dep_hashbrown and hash)
  A HashSet using a default Fx hasher.
• HashSetStdstd
  The HashSet in the standard library.
• HasherBuildFnvhash and cast
  A builder for default Fnv hashers.
• HasherBuildFxhash
  A builder for default Fx hashers.
• ImageResultimage
  ⚖️ An image-related result.
• IoResult
  ⚖️ ?std A specialized Result type for I/O operations.
• LINUX_SYSlinux
  Linux sys/syscall.h constants for the current compilation target.
• LayoutResultlayout
  ⚖️ A layout-related result.
• LockResultstd
  std A type alias for the result of a lock method which can be poisoned.
• MediaResultmedia··
  ⚖️ A media-related result.
• MidiResultmidi
  ⚖️ A midi-related result.
• NoNum
  Represents the absence of a number.
• NoTimetime
  Represents the absence of time.
• NonExtremeI8
  A signed integer that is known not to equal its most extreme value (MIN).
• NonExtremeU8
  An unsigned integer that is known not to equal its most extreme value (MAX).
• NonExtremeU16
  An unsigned integer that is known not to equal its most extreme value (MAX).
• NonZeroI8
  core A signed integer that is known not to equal zero.
• NonZeroI16
  core A signed integer that is known not to equal zero.
• NonZeroI32
  core A signed integer that is known not to equal zero.
• NonZeroI64
  core A signed integer that is known not to equal zero.
• NonZeroI128
  core A signed integer that is known not to equal zero.
• NonZeroIsize
  core A signed integer that is known not to equal zero.
• NonZeroU8
  core An unsigned integer that is known not to equal zero.
• NonZeroU16
  core An unsigned integer that is known not to equal zero.
• NonZeroU32
  core An unsigned integer that is known not to equal zero.
• NonZeroU64
  core An unsigned integer that is known not to equal zero.
• NonZeroU128
  core An unsigned integer that is known not to equal zero.
• NonZeroUsize
  core An unsigned integer that is known not to equal zero.
• NumResult
  ⚖️ A numeric-related result.
• OptRes
  An optional result for simple ternary logic.
• Point2dgeom
  A specific position in 2d-space without a size.
• Point3dgeom
  A specific position in 3d-space without a size.
• StackU8_stack_u8
  A Stack with an 8-bit index size.
• StackU16_stack_u16
  A Stack with a 16-bit index size.
• StackU32_stack_u32
  A Stack with a 32-bit index size.
• StackUsize_stack_usize
  A Stack with a pointer-sized index size.
• ThreadResultstd
  ⚖️ std A specialized Result type for threads.
• TimeSplitHourNanotime
  A time split from hours to nanoseconds.
• TimeSplitHourNanoNormtime
  A time split from hours to seconds, normalized (128b size & payload).
• TimeSplitHourSectime
  A time split from hours to seconds.
• TimeSplitHourSecNormtime
  A time split from hours to seconds, normalized (128b size, 80b payload).
• TimeSplitMilliNanotime
  A time split from milliseconds to nanoseconds.
• TimeSplitMilliNanoNormtime
  A time split from milliseconds to nanoseconds, normalized (48b size & payload).
• TimeSplitNormtime
  A time split from years to nanoseconds, normalized (192b size, 152b payload).
• TimeSplitYearDaytime
  A time split from years to days.
• TimeSplitYearDayNormtime
  A time split from years to days, normalized (128b size, 80b payload).
• TimeSplitYearSectime
  A time split from years to seconds.
• TimeSplitYearSecNormtime
  A time split from years to seconds, normalized (128b size, 104b payload).
• TryLockResultstd
  ⚖️ std A type alias for the result of a nonblocking locking method.
• UiResultui··
  ⚖️ A user-interface result.
• Vector2dalg
  A static 2-dimensional vector.
• Vector3dalg
  A static 3-dimensional vector.
• c_char
  ⚙️ core Equivalent to the corresponding C type.
• c_double
  ⚙️ core Equivalent to the corresponding C type.
• c_float
  ⚙️ core Equivalent to the corresponding C type.
• c_int
  ⚙️ core Equivalent to the corresponding C type.
• c_long
  ⚙️ core Equivalent to the corresponding C type.
• c_longlong
  ⚙️ core Equivalent to the corresponding C type.
• c_schar
  ⚙️ core Equivalent to the corresponding C type.
• c_short
  ⚙️ core Equivalent to the corresponding C type.
• c_uchar
  ⚙️ core Equivalent to the corresponding C type.
• c_uint
  ⚙️ core Equivalent to the corresponding C type.
• c_ulong
  ⚙️ core Equivalent to the corresponding C type.
• c_ulonglong
  ⚙️ core Equivalent to the corresponding C type.
• c_ushort
  ⚙️ core Equivalent to the corresponding C type.
• char
  ⚙️ core A 32-bit unicode scalar.
• fsize
  ⚙️ A pointer-sized floating-point primitive.
• isize_down
  ⚙️ A downcasted pointer-sized signed integer primitive.
• isize_up
  ⚙️ An upcasted pointer-sized signed integer primitive.
• usize_down
  ⚙️ A downcasted pointer-sized unsigned integer primitive.
• usize_up
  ⚙️ An upcasted pointer-sized unsigned integer primitive.

Unions

• MaybeUninit
  core A wrapper type to construct uninitialized instances of T.

Attribute Macros

• compile
  devela_macros Conditionally compiles the thing it is attached to based on the predicate.
• compile_attr
  devela_macros Conditionally compiles the given attributes based on the predicate.
• autodiffExperimentalnightly_autodiff
  core Automatic Differentiation macro.

Derive Macros

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