destack

import destack

Namespaces

- accessibility — accessibility namespace.
- arc — arc namespace.
- arena — arena namespace.
- assert — assert namespace.
- audio — audio namespace.
- bench — bench namespace.
- binding — binding namespace.
- broadcast — broadcast namespace.
- bytes — bytes namespace.
- cell — cell namespace.
- channel — channel namespace.
- compute — compute namespace.
- console — console namespace.
- convert — convert namespace.
- cow — cow namespace.
- crypto — crypto namespace.
- debug — debug namespace.
- device — device namespace.
- display — display namespace.
- dns — dns namespace.
- ffi — ffi namespace.
- fs — fs namespace.
- fuzz — fuzz namespace.
- gpu — gpu namespace.
- hint — hint namespace.
- http — http namespace.
- https — https namespace.
- input — input namespace.
- io — io namespace.
- ipc — ipc namespace.
- json — json namespace.
- mpmc — mpmc namespace.
- mpsc — mpsc namespace.
- net — net namespace.
- oneshot — oneshot namespace.
- os — os namespace.
- path — path namespace.
- process — process namespace.
- profile — profile namespace.
- random — random namespace.
- range — range namespace.
- raw — raw namespace.
- rc — rc namespace.
- regexp — regexp namespace.
- runtime — runtime namespace.
- schema — schema namespace.
- serde — serde namespace.
- simulation — simulation namespace.
- stream — stream namespace.
- sync — sync namespace.
- sys — sys namespace.
- telemetry — telemetry namespace.
- tensor — tensor namespace.
- test — test namespace.
- time — time namespace.
- tls — tls namespace.
- topology — topology namespace.
- tty — tty namespace.
- types — types namespace.
- url — url namespace.
- watch — watch namespace.
- worker — worker namespace.
- zlib — zlib namespace.

Classes

- Array — A growable compact array.
- AsyncGenerator — Async generator object.
- AsyncMutex — Asynchronous mutual exclusion lock.
- AsyncOnce — One-time async execution state.
- AsyncOnceCell — One-time async initialized cell.
- AsyncRwLock — Asynchronous reader-writer lock.
- AsyncSemaphore — Asynchronous counting semaphore.
- BigInt — Arbitrary-precision integer.
- Binding — One dynamically scoped binding family.
- ByteBuffer — Growable byte buffer.
- ByteReader — Sequential byte reader over in-memory bytes.
- ConcurrentMap — A sharded concurrent hash map.
- ConcurrentQueue — A concurrent multi-producer multi-consumer queue.
- ConcurrentSet — A sharded concurrent hash set.
- Context — One immutable dynamically scoped execution context.
- ContextVar — One dynamically scoped execution value.
- Deque — A compact double-ended queue.
- Generator — Generator object.
- JSON — JavaScript-shaped JSON API.
- JsonDeserializer — JSON decoder.
- JsonSerializer — JSON encoder.
- LinkedList — A linked list.
- Map — A compact hash map.
- Math — Floating point math functions and constants.
- Notify — Asynchronous notification primitive.
- Number — Number constants and parsing functions.
- Promise — Value produced by asynchronous execution.
- Reflect — Static reflection namespace.
- RegExp — Regular expression pattern.
- Set — A compact hash set.
- SortedMap — A compact sorted map.
- SortedSet — A compact sorted set.
- String — Immutable UTF-8 string.
- StringBuilder — Mutable UTF-8 string builder with growable backing storage.
- Task — Single-consumer asynchronous result on its own fiber.

Structs

- AllocationCapacityOverflow — Allocation failed because the requested capacity cannot be represented.
- AllocationOutOfMemory — Allocation failed because the runtime could not reserve enough memory.
- AllocationUnsupported — Allocation failed because the runtime does not support the requested operation.
- AsyncMutexGuard — Active async mutex guard.
- AsyncRwLockReadGuard — Active async readonly lock guard.
- AsyncRwLockWriteGuard — Active async exclusive lock guard.
- AsyncSemaphorePermit — Active async semaphore permit.
- AxisSet — Axis set used by reductions and broadcasts.
- BinaryHeap — A binary max-heap.
- Break — Breaking Try branch.
- Buffer — Typed storage allocated on one compute device.
- BufferCopyRegion — Byte region copied between compute buffers.
- BufferOptions — Allocation options for a compute buffer.
- Cell — Interior mutable storage for copyable values.
- Complex — Complex number with floating-point components.
- ComputeError — Portable compute error.
- ConcurrentMapEntry — Entry guard for one concurrent map key.
- ConcurrentMapRead — Read guard for one concurrent map entry.
- ConcurrentMapWrite — Write guard for one concurrent map entry.
- ConcurrentSetRead — Read guard for one concurrent set value.
- Continue — Continuing Try branch.
- ConvolutionAxes — Axis mapping for tensor convolution.
- ConvolutionGroups — Grouping parameters for tensor convolution.
- ConvolutionWindow — Window parameters for tensor convolution.
- Coordinate — Tensor coordinate with Rank indices.
- CowBorrowed — Borrowed copy-on-write value.
- CowOwned — Owned copy-on-write value.
- DecodeError — Byte decoding failure.
- DeviceCapabilities — Compute capabilities exposed by one device.
- DeviceLimits — Portable compute limits for one device.
- DeviceMemory — Compute device memory snapshot.
- DeviceProperties — Compute device properties visible to portable code.
- DeviceQuery — Query used to select compute devices.
- DotAxes — Axis mapping for tensor dot.
- DropIterator — Iterator that skips an initial number of yielded values.
- Err — Failed result variant.
- FactorizationOptions — Options for matrix factorizations.
- Fiber — Cooperative execution on the current Worker.
- FilterIterator — Iterator that retains yielded values accepted by a predicate.
- FlatMapIterator — Iterator that maps each value to an iterable and yields its values.
- GatherAxes — Axis mapping for tensor gather.
- GeneratorChannel — Step surface passed to one lowered generator body.
- GeneratorResumeFinish — Run the body's return path with one completion value.
- GeneratorResumeNext — Continue the body with one sent value.
- HostErrorContextAudio — Audio host-error context payload.
- HostErrorContextDevice — Device host-error context payload.
- HostErrorContextDisplay — Display host-error context payload.
- HostErrorContextFfi — FFI host-error context payload.
- HostErrorContextGeneric — Generic host-error context payload.
- HostErrorContextGpu — GPU host-error context payload.
- HostErrorContextIo — I/O host-error context payload.
- HostErrorContextIoDriver — I/O-driver host-error context payload.
- HostErrorContextIpc — IPC host-error context payload.
- HostErrorContextNet — Network host-error context payload.
- HostErrorContextProcess — Process host-error context payload.
- HostErrorContextResource — Resource host-error context payload.
- HostErrorContextSecurity — Security host-error context payload.
- HostErrorContextTimer — Timer host-error context payload.
- HostPathPayloadBytes — Byte-path payload attached to an error context.
- HostPathPayloadUtf16 — UTF-16 path payload attached to an error context.
- HostSystemSourceEai — EAI source payload.
- HostSystemSourceErrno — POSIX errno source payload.
- HostSystemSourceHResult — HRESULT source payload.
- HostSystemSourceOther — Other source payload.
- HostSystemSourceSignal — Signal source payload.
- HostSystemSourceWinsock — Winsock source payload.
- InspectIterator — Iterator that observes each yielded value.
- IoError — Portable I/O failure.
- IteratorReturn — A completed iterator value.
- IteratorYield — A yielded iterator value.
- JsonError — JSON parse, stringify, encode, or decode error.
- JsonParseContext — Source context passed to a JSON reviver.
- KernelParameter — Kernel parameter visible through reflection.
- KernelSignature — Kernel entry point metadata.
- Layout — Target-specific layout for one type.
- LayoutField — Target-specific layout for one aggregate field.
- LayoutVariant — Target-specific layout for one variant case.
- MapEntry — One map entry.
- MapEntryHandle — Mutating access to one map entry.
- MapIterator — Iterator that maps each yielded value.
- Matrix2 — Two-by-two matrix in row-major field order.
- Matrix3 — Three-by-three matrix in row-major field order.
- Matrix4 — Four-by-four matrix in row-major field order.
- MeshAxis — Named axis inside a compute mesh.
- NamedAxis — Named axis metadata used by frontends and debugging tools.
- NormalizationOptions — Options for normalization operations.
- Ok — Successful result variant.
- Padding — Padding for a tensor with Rank axes.
- Panic — Panic instance observed by hooks and supervisors.
- PathError — I/O failure attached to a path operation.
- PeekableIterator — Iterator with one buffered yielded value.
- Permutation — Axis permutation with Rank entries.
- PoolOptions — Window options for pooling.
- PoolWindow — Window parameters for pooling.
- ProgramBinary — Binary compute program source.
- ProgramDiagnostic — Diagnostic emitted while compiling a compute program.
- ProgramLocation — Source location for a compute program diagnostic.
- ProgramOptions — Compile options for one compute program.
- ProgramReport — Report from compiling a compute program.
- ProgramText — Text compute program source.
- PromiseResolvers — Promise with its resolving function.
- Quaternion — Quaternion rotation value.
- Range — Half-open range start..end.
- RangeFrom — Range from start...
- RangeFull — Full range ...
- RangeInclusive — Inclusive range start..=end.
- RangeIterator — Iterator over a stepped range.
- RangeTo — Range to ..end.
- RangeToInclusive — Inclusive range to ..=end.
- ReceiveError — Failed receive operation.
- RegExpIndices — Match spans produced by the d flag.
- RegExpMatch — One regular expression match.
- RegExpSpan — Half-open match span in UTF-16 code units.
- Report — Erased error value for application boundaries.
- ScatterAxes — Axis mapping for tensor scatter.
- SendError — Failed send operation.
- Shape — Tensor shape with Rank axes.
- Slab — A generational slab with stable keys and reusable slots.
- SliceWindow — Slice window for a tensor with Rank axes.
- SmallArray — A growable contiguous array with inline storage.
- SoftmaxOptions — Options for softmax-like operations.
- SortedMapEntry — One sorted map entry.
- SortedMapEntryHandle — Mutating access to one sorted map entry.
- TakeIterator — Iterator limited to an initial number of yielded values.
- TaskScope — Structured owner of spawned tasks.
- TensorConvertOptions — Output options for tensor conversion.
- TensorConvolutionOptions — Output options for tensor convolution.
- TensorCreateOptions — Allocation options for a new tensor.
- TensorExecutionOptions — Execution options for tensor work.
- TensorOutputOptions — Output options for tensor operations.
- TensorReduceOptions — Output options for tensor reductions.
- TensorScatterOptions — Output options for tensor scatter.
- Vector2 — Two-dimensional vector.
- Vector3 — Three-dimensional vector.
- Vector4 — Four-dimensional vector.
- WorkgroupCount — Number of workgroups to dispatch.
- WorkgroupSize — Workgroup size for one kernel dispatch.

Enums

- ComputeErrorKind — Compute failure category.
- ConvertMode — Conversion mode for tensor element conversion.
- DeviceFeature — Optional compute feature exposed by a device.
- DeviceKind — Compute execution and storage device kind.
- FactorizationMode — Matrix factorization mode.
- HostAccess — Host mapping permission for a compute buffer.
- HostErrorCode — Error code returned by host bindings.
- IoErrorKind — Portable I/O error category.
- JsonErrorKind — JSON error category.
- KernelParameterKind — Kernel parameter kind.
- MemoryOrder — Memory order for dense tensor storage.
- Ordering — Result of a comparison operation.
- ProgramDiagnosticSeverity — Severity of a compute program diagnostic.
- ProgramFormat — Format for a compute program source.
- ReceiveErrorKind — Channel receive failure kind.
- Reduction — Reduction used when partial tensor shards are combined.
- ScatterMode — Update mode for tensor scatter.
- SendErrorKind — Channel send failure kind.

Newtypes

- AccessOf — Extract the access mode of T.
- AccessOr — Extract the access mode of T, or fall back to D.
- AllocationError — Allocation failure returned by typed fallible allocation APIs.
- allow — Suppress a diagnostic.
- AsyncResult — Async recoverable success or failure.
- Axis — Axis index inside a tensor rank.
- BaseOf — Extract the unqualified base type of T.
- Borrowed — Borrowed access form for exactly T.
- Bound — One endpoint of a range.
- Box — A uniquely owned heap allocation for an owned T.
- capture — Configure closure capture modes for a lambda.
- CloneIterator — Iterator that clones borrowed values.
- cold — Hint that a function is on a cold path.
- ControlFlow — Result of branching a Try carrier.
- CopyIterator — Iterator that copies borrowed values.
- Cow — Copy-on-write value.
- Dense — Dense contiguous tensor format.
- deny — Report a diagnostic as an error.
- deprecated — Marks a declaration as deprecated.
- derive — Derive provider dispatcher.
- Device — Compute device identity and placement handle.
- Dynamic — Erased runtime value for interface constraint T.
- Event — Completion marker recorded on a compute stream.
- expect — Expect a diagnostic.
- experimental — Marks a declaration as experimental.
- Extent — Runtime size along one tensor axis.
- extern — Marks a declaration as externally linked.
- forbid — Forbid overriding a diagnostic error.
- Function — Callable value type, repeatable by default and affine when invoked once.
- HostError — Error returned by host bindings.
- HostErrorContext — Typed context for host error metadata.
- HostPathPayload — Path payload attached to an error context.
- HostSystemSource — Host-level system source metadata.
- hot — Hint that a function is on a hot path.
- inline — Inline hint for generated code.
- intrinsic — Compiler intrinsic marker.
- IsBorrowed — Return whether T is borrowed.
- IsManaged — Return whether T is managed.
- IsOwned — Return whether T is owned.
- IsRaw — Return whether T is raw.
- IsShared — Return whether T is explicitly placed in shared space.
- IsSharedIn — Return whether T resolves to shared space in concrete space S.
- IteratorResult — The union of iterator yield and completion results.
- Json — JSON value.
- Kernel — Callable entry point inside a compute program.
- KernelArgument — Encoded kernel argument.
- languageItem — Compiler language item marker.
- LayoutShape — Reflected layout shape.
- Lifetime — Lifetime marker for borrowed validity.
- LifetimeOf — Extract the borrow lifetime of T.
- LifetimeOr — Extract the borrow lifetime of T, or fall back to D.
- likely — Hint that a branch is likely to be taken.
- Managed — Default managed form for exactly T.
- ManuallyDrop — Owned storage whose Drop does not run automatically.
- MaybeUninit — Storage for T whose lifetime may not have started.
- Mesh — Multi-device placement topology.
- mustUse — Warn when a return value is ignored.
- noAliasingMutableBorrows — Ban aliasing mutable borrows.
- noDynamicDispatch — Forbid dynamic dispatch.
- noHeap — Forbid heap allocation.
- noImplicitReceivers — Ban implicit method receivers.
- noinline — No-inline hint for generated code.
- noManaged — Forbid managed values and managed allocation.
- noReflection — Forbid runtime reflection.
- noRuntime — Forbid runtime-dependent language features.
- noUnsafe — Forbid unsafe operations.
- noUnwind — Forbid unwinding.
- Owned — Unique ownership form for exactly T.
- OwnershipOf — Extract the outer ownership form of T.
- OwnershipOr — Extract the ownership of T, or fall back to D.
- Partial — Store partial results across one mesh axis.
- PayloadOf — Extract the payload under the outermost memory form.
- Phantom — Zero-sized marker for ownership, variance, and drop behavior.
- Pin — Address-stable storage wrapper.
- Placed — Placement form for exactly T.
- PlaceIn — Resolve relative placement in concrete space S.
- PlaceOf — Extract the placement of T.
- PlaceOr — Extract the placement of T, or fall back to D.
- Program — Compiled compute code for one device.
- ProgramSource — Compute program source.
- pure — Mark a function as free of observable side effects.
- Raw — Unsafe raw pointer form for exactly T.
- Replicate — Replicate one tensor axis across the mesh.
- repr — Specify the representation for a declaration.
- Result — Recoverable success or failure.
- safe — Marks a declaration as containing unsafe implementation details behind a safe API.
- Shard — Split one tensor axis across one mesh axis.
- Sharding — Tensor storage partitioned or replicated across a compute mesh.
- sink — Marks a declaration as a boundary where tainted data leaves.
- SlabKey — Key for one live slab entry.
- Slice — Well-known library type for the builtin slice descriptor form [T].
- source — Marks a declaration as a boundary where tainted data enters.
- SpaceOf — Extract the explicit concrete space of T.
- SpaceOr — Extract the explicit concrete space of T, or fall back to D.
- StackFrameId — Opaque identity for a runtime stack frame.
- StaticKey — One reflected static property key.
- Stream — Ordered command stream for one compute device.
- Stride — Tensor element stride.
- Strided — Explicit strided tensor view format.
- StringSlice — Borrowed UTF-8 string slice.
- tailcall — Hint that a function should use a tail call.
- taint — Marks data as carrying one taint.
- Tensor — Owning tensor value.
- TensorView — Borrowed view over tensor storage.
- Type — Reflected semantic type for T.
- TypeId — Stable type identifier.
- Unique — Unique traced heap handle containing exactly T.
- unlikely — Hint that a branch is unlikely to be taken.
- unroll — Loop unroll hint for generated code.
- unsafe — Marks an API, expression, or block as crossing an unsafe boundary.
- UnsafeCell — Unsafe interior mutable storage.
- Unsharded — Tensor storage on one device.
- untaint — Marks a declaration as removing taints for one boundary domain.
- Vector — Fixed-width vector type.
- warn — Report a diagnostic as a warning.
- WithAccess — Reborrow Q with access mode A.
- WithBase — Replace the unqualified base type of Q with T.
- WithLifetime — Reborrow Q with lifetime L.
- WithOwnership — Add ownership form O around Q.
- WithPlace — Replace placement of Q with place P.
- WithSpace — Resolve relative placement of Q in concrete space S.
- Wrapping — Integer wrapper whose operators use modular arithmetic.

Newtype interfaces

- Add — Interface for the + operator.
- And — Interface for the & operator.
- As — Interface for reference conversion.
- AsyncDispose — Deterministic asynchronous cleanup capability, called at the end of an await using scope.
- AsyncIterable — Value that can produce an async iterator.
- AsyncIterator — Protocol for asynchronously producing values.
- Borrow — Equivalent borrowed form of a value.
- Clone — Mark a type as explicitly cloneable.
- Compare — Interface for total comparison and ordering.
- Concrete — Mark a type as having a complete storage representation.
- Copy — Mark a type as implicitly duplicable without ownership transfer.
- Debug — Interface for developer-facing string representation.
- Default — Mark a type as having a conventional default value.
- Dereference — Interface for dereference projection a.
- Deserialize — Value that can be deserialized through D.
- Deserializer — Structured value deserializer.
- Display — Interface for user-facing string representation.
- Dispose — Deterministic synchronous cleanup capability, called at the end of a using scope.
- Divide — Interface for the / operator.
- Drop — Ownership finalization capability.
- DynamicSafe — Mark a type as safe for runtime erasure.
- Equal — Marker interface for total equality.
- Error — Recoverable failure protocol.
- Extend — Collection extended from an iterable sequence.
- Float — Marker for the builtin float formats of any width.
- FloatDomain — Marker for float literals and builtin float types.
- From — Infallible conversion from T.
- FromIterator — Collection built from an iterator.
- FromResidual — Target protocol for rebuilding a carrier from a propagated residual.
- Hash — A value that can feed itself into a hasher.
- Hasher — A stateful hash sink.
- Index — Interface for index access a[i].
- IndexSet — Interface for index assignment a[i] = v.
- Integer — Marker for the builtin integer types of any width.
- IntegerDomain — Marker for integer literals, intervals, and builtin integer types.
- Into — Infallible conversion into T.
- Iterable — A value that can produce an iterator.
- Iterator — A protocol for producing a sequence of values.
- Multiply — Interface for the  operator.
- Negate — Interface for unary -.
- Not — Interface for the  operator.
- One — Numeric type with a multiplicative identity.
- Or — Interface for the | operator.
- OverwriteStable — Mark a type as safe to overwrite through non-exclusive mutable access.
- PartialCompare — Interface for partial comparison.
- PartialEqual — Interface for partial equality.
- Placement — Tensor placement descriptor.
- Plus — Interface for unary +.
- Power — Interface for the  operator.
- RangeBounds — Common protocol for range bounds.
- Remainder — Interface for the % operator.
- Sequence — Finite ordered collection destructured by sequence patterns.
- Serialize — Value that can serialize itself through S.
- Serializer — Structured value serializer.
- ShardingAxis — Per-axis placement descriptor used by a sharded tensor.
- SharedSafe — Mark a type as safe to store in shared space.
- ShiftLeft — Interface for the > operator.
- ShiftRightUnsigned — Interface for the >>> operator.
- Step — Protocol for values that can advance through a range.
- Subtract — Interface for the - operator.
- TensorFormat — Format implemented by owning tensor storage.
- TensorViewFormat — Format implemented by borrowed tensor views.
- ThisType — Marker for contextual object this typing.
- ToOwned — Owned form of a borrowed value.
- Try — Protocol for values that work with ?, ??, and postfix !.
- TryFrom — Fallible conversion from T.
- TryInto — Fallible conversion into T.
- Unpin — Mark a type as safe to move out of pinned storage.
- Xor — Interface for the ^ operator.
- Zero — Numeric type with an additive identity.
- Zeroable — Mark a type as valid when all bytes are zero.

Interfaces

- AsyncReader — Asynchronous byte reader.
- AsyncReceiver — Asynchronous receiver endpoint.
- AsyncSeeker — Asynchronous seekable byte stream.
- AsyncSender — Asynchronous sender endpoint.
- AsyncWriter — Asynchronous byte writer.
- ChannelOptions — Channel buffer options.
- ComputeBinding — Compute binding family.
- ImportMeta — Metadata about the current module and build configuration.
- ImportMetaEnv — Environment variables available at compile time.
- ImportMetaTarget — Structured target metadata.
- MemoryBinding — Memory binding family.
- Module — Static configuration for one source module.
- Receiver — Synchronous receiver endpoint.
- Sender — Synchronous sender endpoint.

Type aliases

- Access — Access mode for qualified storage.
- Awaited — Recursively unwrap promise-like values.
- BorrowedFields — Rebase each field of T into borrowed form.
- ByteOrder — Byte order for numeric encoding.
- Bytes — Immutable byte sequence.
- Capitalize — Map each string in S to capitalize its first character.
- CaptureDirective — Capture directive value for the capture decorator.
- CaptureMode — Capture mode for closure bindings.
- ColumnMajorFormat — Column-major dense tensor format.
- Complexd — Double-precision complex number.
- Complexf — Single-precision complex number.
- ConstructorParameters — Extract the parameter tuple from a constructor type.
- Derive — Well-known derive considered automatically for nominal declarations.
- DiagnosticControlOptions — Options for scoped diagnostic controls.
- DiagnosticId — A canonical diagnostic id.
- Exclude — Remove union members of T assignable to U.
- ExclusiveBorrowed — Exclusive borrowed access to T within lifetime L.
- ExclusiveBorrowedFields — Rebase each field of T into exclusive borrowed form.
- Extract — Keep union members of T assignable to U.
- FixedArray — Fixed-size array alias.
- GeneratorResult — The union of generator yield and return results.
- GeneratorResume — One consumer request delivered back into a generator body.
- Host — The target host environment that provides imports and ambient effects.
- InlineHint — Inline policy for a function.
- InstanceType — Extract the instance type from a constructor type.
- JsonArray — JSON array value.
- JsonDeserialize — Value that can be decoded from JSON.
- JsonObject — JSON object value.
- JsonPathSegment — JSON object key or array index.
- JsonReplacer — Function that transforms JSON values before serialization.
- JsonReviver — Function that transforms parsed JSON values.
- JsonSerialize — Value that can encode itself as JSON.
- LaneCount — Return the number of lanes in Vector.
- LaneOf — Return the element type in Vector.
- Local — Place T in local space.
- LocalFields — Rebase each field of T into local space.
- Lowercase — Map each string in S to its lowercase form.
- ManagedFields — Rebase each field of T into managed form.
- Mask — Vector mask type.
- Matrix2d — Two-by-two double-precision matrix.
- Matrix2f — Two-by-two single-precision matrix.
- Matrix2i — Two-by-two signed integer matrix.
- Matrix3d — Three-by-three double-precision matrix.
- Matrix3f — Three-by-three single-precision matrix.
- Matrix3i — Three-by-three signed integer matrix.
- Matrix4d — Four-by-four double-precision matrix.
- Matrix4f — Four-by-four single-precision matrix.
- Matrix4i — Four-by-four signed integer matrix.
- MaybeOwned — Readonly borrowed or owned value.
- MutableFields — Make each field of T mutable.
- NoInfer — Block inference from this use of T.
- NonNullable — Remove null and undefined from T.
- NumberFormatOptions — Number locale formatting options.
- Numeric — Any sized machine scalar, excluding bigint.
- NumericDomain — Any numeric literal, interval, or sized machine scalar, excluding bigint.
- Omit — Remove fields K from T.
- OmitThisParameter — Remove the explicit receiver from a callable type.
- Output — The artifact produced by the current build target.
- OwnedFields — Rebase each field of T into owned form.
- Ownership — Ownership kind for qualified storage.
- PanicHook — Runtime hook invoked before a panic starts unwinding.
- Parameters — Extract the parameter tuple from a callable type.
- Partial — Make each field of T optional.
- Pick — Keep fields K from T.
- Place — Placement tag kind for qualified storage.
- Platform — The target platform (OS) the code is being compiled for.
- PropertyKey — Type of valid object property keys.
- Quaterniond — Double-precision quaternion.
- Quaternionf — Single-precision quaternion.
- RawFields — Rebase each field of T into raw pointer form.
- Readonly — Make T deeply readonly.
- ReadonlyArray — Readonly view of a dynamic array.
- ReadonlyBorrowed — Readonly borrowed access to T within lifetime L.
- ReadonlyBorrowedFields — Rebase each field of T into readonly borrowed form.
- Record — Object type with keys K and values V.
- RegExpGroups — Named regular expression capture groups.
- RegExpIndexGroups — Named spans for regular expression capture groups.
- Relative — Restore relative placement of T.
- RelativeFields — Rebase each field of T into relative placement.
- Representation — Representation policy for a declaration.
- RepresentationOptions — Representation options for a declaration.
- Required — Make each field of T required.
- ReturnType — Extract the return type from a callable type.
- RowMajorFormat — Row-major dense tensor format.
- Runtime — The semantic runtime contract for the build.
- Shared — Place T in shared space.
- SharedFields — Rebase each field of T into shared space.
- SinkOptions — Options for sink boundaries.
- SourceLocation — Source location for a stack frame.
- SourceOptions — Options for source boundaries.
- Space — Concrete memory space tag kind.
- StackFrame — One frame in a stack trace.
- StackTrace — Structured stack trace.
- StackTraceOptions — Stack trace capture options.
- Stage — The package release stage.
- StaticLifetime — Builtin lifetime root for static storage.
- StringMatch — Match result from String.match.
- StringRawParts — Raw template string parts.
- StringReplacement — Replacement value used by String.replace and String.replaceAll.
- TaintDomain — Boundary domain where tainted data enters or leaves.
- TaintTag — Taint label carried by a value.
- TargetFamily — Coarse target family metadata.
- ThisParameterType — Extract the explicit receiver from a callable type.
- Uncapitalize — Map each string in S to uncapitalize its first character.
- Unsigned — The unsigned builtin integer type with the same width as T.
- UntaintOptions — Options for untaint boundaries.
- Uppercase — Map each string in S to its uppercase form.
- Vector2d — Two-dimensional double-precision vector.
- Vector2f — Two-dimensional single-precision vector.
- Vector2i — Two-dimensional signed integer vector.
- Vector3d — Three-dimensional double-precision vector.
- Vector3f — Three-dimensional single-precision vector.
- Vector3i — Three-dimensional signed integer vector.
- Vector4d — Four-dimensional double-precision vector.
- Vector4f — Four-dimensional single-precision vector.
- Vector4i — Four-dimensional signed integer vector.

Functions

- abort — Stop execution immediately without unwinding or cleanup.
- absolute — Return elementwise absolute value.
- alignOf — Return the target-specific alignment of T.
- all — Return whether all selected boolean values are true.
- any — Return whether any selected boolean value is true.
- argmax — Return indices of maximum values along axis.
- argmin — Return indices of minimum values along axis.
- assumeInit — Move one initialized storage out as T.
- assumeInitDrop — Drop one initialized storage in place.
- assumeInitExclusiveReference — Borrow one initialized storage with exclusive access.
- assumeInitRead — Copy one initialized storage out without ending it.
- assumeInitReadonlyReference — Borrow one initialized storage with readonly access.
- assumeInitReference — Borrow one initialized storage.
- avgPool — Return average-pooled values.
- bernoulli — Return values sampled from Bernoulli trials.
- bitAnd — Return bitwise AND along the axes in axisSet.
- bitOr — Return bitwise OR along the axes in axisSet.
- bitXor — Return bitwise XOR along the axes in axisSet.
- breakpoint — Trigger a debugger breakpoint.
- broadcast — Broadcast tensor to shape.
- captureStackTrace — Capture a structured stack trace for the current Worker.
- cast — Cast tensor elements to U by bit reinterpretation.
- cholesky — Return the Cholesky factorization.
- clone — Clone bytes into immutable storage.
- compare — Compare two byte sequences lexicographically.
- concat — Concatenate tensors along axis.
- contains — Return whether bytes contains needle.
- convolution — Convolve input with kernel.
- cos — Return elementwise cosine.
- count — Return the number of non-overlapping occurrences of needle.
- decode — Decode typed JSON text.
- decodeUtf8 — Decode UTF-8 bytes as text.
- det — Return the determinant of a matrix.
- diagonal — Return the diagonal of a matrix.
- dot — Multiply and reduce two tensors over configured axes.
- drop — End ownership of value at this point.
- encode — Encode a typed value as JSON text.
- encodeJson — Serialize an already materialized JSON value.
- encodeUtf8 — Encode text as UTF-8 bytes.
- endsWith — Return whether bytes ends with suffix.
- equal — Return elementwise equality.
- equalTypes — Return true when two reflected types name the same normalized type.
- exp — Return elementwise exponential.
- expandDims — Insert a length-one axis.
- extract — Return the lane at index.
- fill — Fill view with value.
- forget — End ownership of value without running its destructor.
- formatStackTrace — Format a structured stack trace as diagnostic text.
- gather — Gather slices from operand.
- gelu — Return Gaussian error linear activation.
- greater — Return elementwise greater-than comparison.
- greaterEqual — Return elementwise greater-than-or-equal comparison.
- indexOf — Return the first index of needle.
- initAsExclusivePointer — Return an exclusive raw pointer to one storage.
- initAsPointer — Return a raw pointer to one storage.
- initNew — Create initialized storage for value.
- initUninit — Create uninitialized storage for T.
- initWrite — Initialize one storage with value.
- initZeroed — Create zeroed storage for T.
- inner — Return the inner product of two vectors.
- insert — Return a vector with one lane replaced.
- inverse — Return the inverse of a matrix.
- join — Join byte sequences with separator.
- lastIndexOf — Return the last index of needle.
- layerNorm — Return layer-normalized values.
- layoutOf — Return the target-specific layout of T.
- less — Return elementwise less-than comparison.
- lessEqual — Return elementwise less-than-or-equal comparison.
- load — Load one tensor element from view.
- log — Return elementwise natural logarithm.
- logSoftmax — Return log-softmax over one axis.
- matmul — Matrix multiply rank-two tensors.
- max — Return maximum values of tensor along the axes in axisSet.
- maxPool — Return max-pooled values.
- mean — Return the mean of tensor along the axes in axisSet.
- min — Return minimum values of tensor along the axes in axisSet.
- negative — Return elementwise negation.
- norm — Return vector or matrix norm along axes.
- normal — Return values sampled from the standard normal distribution.
- notEqual — Return elementwise inequality.
- outer — Return the outer product of two vectors.
- pad — Pad tensor.
- panic — Stop execution with a language panic.
- parse — Parse JSON text.
- product — Multiply elements of tensor along the axes in axisSet.
- qr — Return the QR factorization.
- queueMicrotask — Queue one function after the active task finishes.
- readFloat32 — Read one 32-bit float.
- readFloat64 — Read one 64-bit float.
- readInt16 — Read one signed 16-bit integer.
- readInt32 — Read one signed 32-bit integer.
- readInt64 — Read one signed 64-bit integer.
- readUint16 — Read one unsigned 16-bit integer.
- readUint32 — Read one unsigned 32-bit integer.
- readUint64 — Read one unsigned 64-bit integer.
- reduceAdd — Horizontal reduction: sum all lanes.
- reduceAnd — Horizontal reduction: bitwise AND of all lanes.
- reduceMax — Horizontal reduction: maximum of all lanes.
- reduceMin — Horizontal reduction: minimum of all lanes.
- reduceMul — Horizontal reduction: multiply all lanes.
- reduceOr — Horizontal reduction: bitwise OR of all lanes.
- reduceXor — Horizontal reduction: bitwise XOR of all lanes.
- reformat — Copy tensor data into a new format.
- relu — Return rectified linear activation.
- repeat — Repeat bytes count times.
- replace — Replace destination and return its previous value.
- reshape — Reshape tensor to shape.
- scatter — Scatter updates into operand.
- select — Select tensor elements from thenValue or elseValue.
- setPanicHook — Install the runtime panic hook.
- shuffle — Shuffle vector lanes.
- sigmoid — Return logistic sigmoid activation.
- sin — Return elementwise sine.
- sizeOf — Return the target-specific size of T.
- slice — Slice tensor by window.
- softmax — Return softmax over one axis.
- solve — Solve a linear system.
- splat — Build a tensor by repeating value.
- split — Split bytes around separator.
- splitAfter — Split bytes after each separator.
- sqrt — Return elementwise square root.
- squeeze — Remove length-one axes.
- stack — Stack tensors along a new axis.
- startsWith — Return whether bytes starts with prefix.
- store — Store one tensor element into view.
- strideOf — Return the target-specific stride of T.
- stringify — Serialize a JSON value.
- sum — Sum tensor along the axes in axisSet.
- svd — Return the singular value decomposition.
- swap — Exchange the values at left and right.
- take — Replace destination with its default value and return its previous value.
- takeHostError — Error bindings for runtime error propagation.
- takePanicHook — Remove the runtime panic hook and return the previous hook.
- tan — Return elementwise tangent.
- todo — Stop execution because code is intentionally unfinished.
- trace — Return the trace of a matrix.
- transpose — Transpose tensor by permutation.
- trap — Stop execution with a low-level runtime trap.
- trimAscii — Trim leading and trailing ASCII whitespace.
- trimAsciiEnd — Trim trailing ASCII whitespace.
- trimAsciiStart — Trim leading ASCII whitespace.
- type — Return the reflected type for T.
- typeOf — Return the reflected type for a value.
- uniform — Return values sampled uniformly from 0, 1).
- [uniformRange — Return values sampled uniformly from low, high).
- [unreachable — Mark this code path as unreachable.
- writeFloat32 — Write one 32-bit float.
- writeFloat64 — Write one 64-bit float.
- writeInt16 — Write one signed 16-bit integer.
- writeInt32 — Write one signed 32-bit integer.
- writeInt64 — Write one signed 64-bit integer.
- writeUint16 — Write one unsigned 16-bit integer.
- writeUint32 — Write one unsigned 32-bit integer.
- writeUint64 — Write one unsigned 64-bit integer.
- yieldNow — Yield the current fiber back to the Worker scheduler.

Constants

- Infinity — The positive float infinity.
- memory — Current memory binding family.
- NaN — The float not-a-number value.

Extensions

- Arithmetic — Explicit overflow behaviors for builtin integer arithmetic.
- Cast — Explicit lossy conversions between builtin integer types.