Trait IntoExpand 

pub trait IntoExpand {
    type Expand;

    // Required method
    fn into_expand(self, scope: &Scope) -> Self::Expand;
}

Required Associated Types

type Expand

Required Methods

fn into_expand(self, scope: &Scope) -> Self::Expand

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl IntoExpand for ()

type Expand = ()

fn into_expand(self, _: &Scope) -> <() as IntoExpand>::Expand

impl IntoExpand for Complex<f32>

type Expand = NativeExpand<Complex<f32>>

fn into_expand(self, _scope: &Scope) -> <Complex<f32> as IntoExpand>::Expand

impl IntoExpand for Complex<f64>

type Expand = NativeExpand<Complex<f64>>

fn into_expand(self, _scope: &Scope) -> <Complex<f64> as IntoExpand>::Expand

impl IntoExpand for ComptimeEventBusExpand

type Expand = ComptimeEventBusExpand

fn into_expand(self, _: &Scope) -> ComptimeEventBusExpand

impl IntoExpand for DynamicRankStridedLayoutExpand

type Expand = DynamicRankStridedLayoutExpand

fn into_expand(self, _: &Scope) -> DynamicRankStridedLayoutExpand

impl IntoExpand for KnownScaleExpand

type Expand = KnownScaleExpand

fn into_expand(self, _: &Scope) -> KnownScaleExpand

impl IntoExpand for LinearViewLayoutExpand

type Expand = LinearViewLayoutExpand

fn into_expand(self, _: &Scope) -> LinearViewLayoutExpand

impl IntoExpand for Ordering

type Expand = <Ordering as CubeType>::ExpandType

fn into_expand(self, scope: &Scope) -> <Ordering as IntoExpand>::Expand

impl IntoExpand for PermutedLayoutExpand

type Expand = PermutedLayoutExpand

fn into_expand(self, _: &Scope) -> PermutedLayoutExpand

impl IntoExpand for PlainLayoutExpand

type Expand = PlainLayoutExpand

fn into_expand(self, _: &Scope) -> PlainLayoutExpand

impl IntoExpand for SimpleLayoutExpand

type Expand = SimpleLayoutExpand

fn into_expand(self, _: &Scope) -> SimpleLayoutExpand

impl IntoExpand for StridedLayoutExpand

type Expand = StridedLayoutExpand

fn into_expand(self, _: &Scope) -> StridedLayoutExpand

impl IntoExpand for SwizzleExpand

type Expand = SwizzleExpand

fn into_expand(self, _: &Scope) -> SwizzleExpand

impl IntoExpand for TiledLayoutExpand

type Expand = TiledLayoutExpand

fn into_expand(self, _: &Scope) -> TiledLayoutExpand

impl IntoExpand for TiledViewLayoutExpand

type Expand = TiledViewLayoutExpand

fn into_expand(self, _: &Scope) -> TiledViewLayoutExpand

impl IntoExpand for bf16

type Expand = NativeExpand<bf16>

fn into_expand(self, _: &Scope) -> <bf16 as IntoExpand>::Expand

impl IntoExpand for bool

type Expand = NativeExpand<bool>

fn into_expand(self, _: &Scope) -> <bool as IntoExpand>::Expand

impl IntoExpand for f16

type Expand = NativeExpand<f16>

fn into_expand(self, _: &Scope) -> <f16 as IntoExpand>::Expand

impl IntoExpand for f32

type Expand = NativeExpand<f32>

fn into_expand(self, _: &Scope) -> <f32 as IntoExpand>::Expand

impl IntoExpand for f64

type Expand = NativeExpand<f64>

fn into_expand(self, _: &Scope) -> <f64 as IntoExpand>::Expand

impl IntoExpand for i8

type Expand = NativeExpand<i8>

fn into_expand(self, _: &Scope) -> <i8 as IntoExpand>::Expand

impl IntoExpand for i16

type Expand = NativeExpand<i16>

fn into_expand(self, _: &Scope) -> <i16 as IntoExpand>::Expand

impl IntoExpand for i32

type Expand = NativeExpand<i32>

fn into_expand(self, _: &Scope) -> <i32 as IntoExpand>::Expand

impl IntoExpand for i64

type Expand = NativeExpand<i64>

fn into_expand(self, _: &Scope) -> <i64 as IntoExpand>::Expand

impl IntoExpand for isize

type Expand = NativeExpand<isize>

fn into_expand(self, scope: &Scope) -> <isize as IntoExpand>::Expand

impl IntoExpand for u8

type Expand = NativeExpand<u8>

fn into_expand(self, _: &Scope) -> <u8 as IntoExpand>::Expand

impl IntoExpand for u16

type Expand = NativeExpand<u16>

fn into_expand(self, _: &Scope) -> <u16 as IntoExpand>::Expand

impl IntoExpand for u32

type Expand = NativeExpand<u32>

fn into_expand(self, _: &Scope) -> <u32 as IntoExpand>::Expand

impl IntoExpand for u64

type Expand = NativeExpand<u64>

fn into_expand(self, _: &Scope) -> <u64 as IntoExpand>::Expand

impl IntoExpand for usize

type Expand = NativeExpand<usize>

fn into_expand(self, scope: &Scope) -> <usize as IntoExpand>::Expand

impl<'a, E, C> IntoExpand for ViewExpand<'a, E, C>

where E: CubePrimitive, C: Coordinates,

type Expand = ViewExpand<'a, E, C>

fn into_expand(self, _: &Scope) -> <ViewExpand<'a, E, C> as IntoExpand>::Expand

impl<'a, E, C> IntoExpand for ViewMutExpand<'a, E, C>

where E: CubePrimitive, C: Coordinates,

type Expand = ViewMutExpand<'a, E, C>

fn into_expand( self, _: &Scope, ) -> <ViewMutExpand<'a, E, C> as IntoExpand>::Expand

impl<'a, Q, NQ, S, F, NF, C> IntoExpand for QuantizedViewExpand<'a, Q, NQ, S, F, NF, C>

where Q: Scalar, NQ: Size, S: Scalar, F: Numeric, NF: Size, C: Coordinates + 'static,

type Expand = QuantizedViewExpand<'a, Q, NQ, S, F, NF, C>

fn into_expand(self, _: &Scope) -> QuantizedViewExpand<'a, Q, NQ, S, F, NF, C>

impl<'a, S, T> IntoExpand for ReinterpretSliceExpand<'a, S, T>

where S: CubePrimitive, T: CubePrimitive,

type Expand = ReinterpretSliceExpand<'a, S, T>

fn into_expand(self, _: &Scope) -> ReinterpretSliceExpand<'a, S, T>

impl<'a, S, T> IntoExpand for ReinterpretSliceMutExpand<'a, S, T>

where S: CubePrimitive, T: CubePrimitive,

type Expand = ReinterpretSliceMutExpand<'a, S, T>

fn into_expand(self, _: &Scope) -> ReinterpretSliceMutExpand<'a, S, T>

impl<'a, T> IntoExpand for &'a T

where T: IntoExpand<Expand = T> + ?Sized,

type Expand = &'a T

fn into_expand(self, _: &Scope) -> <&'a T as IntoExpand>::Expand

impl<'a, T> IntoExpand for &'a mut T

where T: IntoExpand<Expand = T> + ?Sized,

type Expand = &'a mut T

fn into_expand(self, _: &Scope) -> <&'a mut T as IntoExpand>::Expand

impl<C, S> IntoExpand for VirtualLayoutExpand<C, S>

where C: Coordinates, S: Coordinates,

type Expand = VirtualLayoutExpand<C, S>

fn into_expand( self, _: &Scope, ) -> <VirtualLayoutExpand<C, S> as IntoExpand>::Expand

impl<C> IntoExpand for SliceLayoutExpand<C>

where C: Coordinates,

type Expand = SliceLayoutExpand<C>

fn into_expand(self, _: &Scope) -> SliceLayoutExpand<C>

impl<D> IntoExpand for FixedDimLayoutExpand<D>

where D: IntoDyn,

type Expand = FixedDimLayoutExpand<D>

fn into_expand(self, _: &Scope) -> FixedDimLayoutExpand<D>

impl<E, IO> IntoExpand for ErasedTensorExpand<E, IO>

where E: Numeric,

type Expand = ErasedTensorExpand<E, IO>

fn into_expand( self, _: &Scope, ) -> <ErasedTensorExpand<E, IO> as IntoExpand>::Expand

impl<E, N, IO> IntoExpand for VirtualTensorExpand<E, N, IO>

where E: Numeric, N: Size, IO: Clone,

type Expand = VirtualTensorExpand<E, N, IO>

fn into_expand( self, _: &Scope, ) -> <VirtualTensorExpand<E, N, IO> as IntoExpand>::Expand

impl<I> IntoExpand for FastDivmodExpand<I>

where I: FastDivmodInt,

type Expand = FastDivmodExpand<I>

fn into_expand(self, _: &Scope) -> FastDivmodExpand<I>

impl<L0, L1> IntoExpand for ChainExpand<L0, L1>

where L0: Layout, L1: Layout<SourceCoordinates = <L0 as Layout>::Coordinates>,

type Expand = ChainExpand<L0, L1>

fn into_expand(self, _: &Scope) -> ChainExpand<L0, L1>

impl<L, P, O> IntoExpand for IntoDyn2LayoutExpand<L, P, O>

where L: Layout<SourceCoordinates = (P, O)> + ViewLayoutLaunchArg, P: IntoDyn, O: IntoDyn,

type Expand = IntoDyn2LayoutExpand<L, P, O>

fn into_expand(self, _: &Scope) -> IntoDyn2LayoutExpand<L, P, O>

impl<L> IntoExpand for ConcreteLayoutExpand<L>

where L: Layout + ViewLayoutLaunchArg,

type Expand = ConcreteLayoutExpand<L>

fn into_expand(self, _: &Scope) -> ConcreteLayoutExpand<L>

impl<L> IntoExpand for IntoDynLayoutExpand<L>

where L: Layout + ViewLayoutLaunchArg, <L as Layout>::SourceCoordinates: IntoDyn,

type Expand = IntoDynLayoutExpand<L>

fn into_expand(self, _: &Scope) -> IntoDynLayoutExpand<L>

impl<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> IntoExpand for (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11)

where P0: IntoExpand, P1: IntoExpand, P2: IntoExpand, P3: IntoExpand, P4: IntoExpand, P5: IntoExpand, P6: IntoExpand, P7: IntoExpand, P8: IntoExpand, P9: IntoExpand, P10: IntoExpand, P11: IntoExpand,

type Expand = (<P0 as IntoExpand>::Expand, <P1 as IntoExpand>::Expand, <P2 as IntoExpand>::Expand, <P3 as IntoExpand>::Expand, <P4 as IntoExpand>::Expand, <P5 as IntoExpand>::Expand, <P6 as IntoExpand>::Expand, <P7 as IntoExpand>::Expand, <P8 as IntoExpand>::Expand, <P9 as IntoExpand>::Expand, <P10 as IntoExpand>::Expand, <P11 as IntoExpand>::Expand)

fn into_expand( self, scope: &Scope, ) -> <(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) as IntoExpand>::Expand

impl<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> IntoExpand for (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)

where P0: IntoExpand, P1: IntoExpand, P2: IntoExpand, P3: IntoExpand, P4: IntoExpand, P5: IntoExpand, P6: IntoExpand, P7: IntoExpand, P8: IntoExpand, P9: IntoExpand, P10: IntoExpand,

type Expand = (<P0 as IntoExpand>::Expand, <P1 as IntoExpand>::Expand, <P2 as IntoExpand>::Expand, <P3 as IntoExpand>::Expand, <P4 as IntoExpand>::Expand, <P5 as IntoExpand>::Expand, <P6 as IntoExpand>::Expand, <P7 as IntoExpand>::Expand, <P8 as IntoExpand>::Expand, <P9 as IntoExpand>::Expand, <P10 as IntoExpand>::Expand)

fn into_expand( self, scope: &Scope, ) -> <(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) as IntoExpand>::Expand

impl<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> IntoExpand for (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)

where P0: IntoExpand, P1: IntoExpand, P2: IntoExpand, P3: IntoExpand, P4: IntoExpand, P5: IntoExpand, P6: IntoExpand, P7: IntoExpand, P8: IntoExpand, P9: IntoExpand,

type Expand = (<P0 as IntoExpand>::Expand, <P1 as IntoExpand>::Expand, <P2 as IntoExpand>::Expand, <P3 as IntoExpand>::Expand, <P4 as IntoExpand>::Expand, <P5 as IntoExpand>::Expand, <P6 as IntoExpand>::Expand, <P7 as IntoExpand>::Expand, <P8 as IntoExpand>::Expand, <P9 as IntoExpand>::Expand)

fn into_expand( self, scope: &Scope, ) -> <(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) as IntoExpand>::Expand

impl<P0, P1, P2, P3, P4, P5, P6, P7, P8> IntoExpand for (P0, P1, P2, P3, P4, P5, P6, P7, P8)

where P0: IntoExpand, P1: IntoExpand, P2: IntoExpand, P3: IntoExpand, P4: IntoExpand, P5: IntoExpand, P6: IntoExpand, P7: IntoExpand, P8: IntoExpand,

type Expand = (<P0 as IntoExpand>::Expand, <P1 as IntoExpand>::Expand, <P2 as IntoExpand>::Expand, <P3 as IntoExpand>::Expand, <P4 as IntoExpand>::Expand, <P5 as IntoExpand>::Expand, <P6 as IntoExpand>::Expand, <P7 as IntoExpand>::Expand, <P8 as IntoExpand>::Expand)

fn into_expand( self, scope: &Scope, ) -> <(P0, P1, P2, P3, P4, P5, P6, P7, P8) as IntoExpand>::Expand

impl<P0, P1, P2, P3, P4, P5, P6, P7> IntoExpand for (P0, P1, P2, P3, P4, P5, P6, P7)

where P0: IntoExpand, P1: IntoExpand, P2: IntoExpand, P3: IntoExpand, P4: IntoExpand, P5: IntoExpand, P6: IntoExpand, P7: IntoExpand,

type Expand = (<P0 as IntoExpand>::Expand, <P1 as IntoExpand>::Expand, <P2 as IntoExpand>::Expand, <P3 as IntoExpand>::Expand, <P4 as IntoExpand>::Expand, <P5 as IntoExpand>::Expand, <P6 as IntoExpand>::Expand, <P7 as IntoExpand>::Expand)

fn into_expand( self, scope: &Scope, ) -> <(P0, P1, P2, P3, P4, P5, P6, P7) as IntoExpand>::Expand

impl<P0, P1, P2, P3, P4, P5, P6> IntoExpand for (P0, P1, P2, P3, P4, P5, P6)

where P0: IntoExpand, P1: IntoExpand, P2: IntoExpand, P3: IntoExpand, P4: IntoExpand, P5: IntoExpand, P6: IntoExpand,

type Expand = (<P0 as IntoExpand>::Expand, <P1 as IntoExpand>::Expand, <P2 as IntoExpand>::Expand, <P3 as IntoExpand>::Expand, <P4 as IntoExpand>::Expand, <P5 as IntoExpand>::Expand, <P6 as IntoExpand>::Expand)

fn into_expand( self, scope: &Scope, ) -> <(P0, P1, P2, P3, P4, P5, P6) as IntoExpand>::Expand

impl<P0, P1, P2, P3, P4, P5> IntoExpand for (P0, P1, P2, P3, P4, P5)

where P0: IntoExpand, P1: IntoExpand, P2: IntoExpand, P3: IntoExpand, P4: IntoExpand, P5: IntoExpand,

type Expand = (<P0 as IntoExpand>::Expand, <P1 as IntoExpand>::Expand, <P2 as IntoExpand>::Expand, <P3 as IntoExpand>::Expand, <P4 as IntoExpand>::Expand, <P5 as IntoExpand>::Expand)

fn into_expand( self, scope: &Scope, ) -> <(P0, P1, P2, P3, P4, P5) as IntoExpand>::Expand

impl<P0, P1, P2, P3, P4> IntoExpand for (P0, P1, P2, P3, P4)

where P0: IntoExpand, P1: IntoExpand, P2: IntoExpand, P3: IntoExpand, P4: IntoExpand,

type Expand = (<P0 as IntoExpand>::Expand, <P1 as IntoExpand>::Expand, <P2 as IntoExpand>::Expand, <P3 as IntoExpand>::Expand, <P4 as IntoExpand>::Expand)

fn into_expand( self, scope: &Scope, ) -> <(P0, P1, P2, P3, P4) as IntoExpand>::Expand

impl<P0, P1, P2, P3> IntoExpand for (P0, P1, P2, P3)

where P0: IntoExpand, P1: IntoExpand, P2: IntoExpand, P3: IntoExpand,

type Expand = (<P0 as IntoExpand>::Expand, <P1 as IntoExpand>::Expand, <P2 as IntoExpand>::Expand, <P3 as IntoExpand>::Expand)

fn into_expand(self, scope: &Scope) -> <(P0, P1, P2, P3) as IntoExpand>::Expand

impl<P0, P1, P2> IntoExpand for (P0, P1, P2)

where P0: IntoExpand, P1: IntoExpand, P2: IntoExpand,

type Expand = (<P0 as IntoExpand>::Expand, <P1 as IntoExpand>::Expand, <P2 as IntoExpand>::Expand)

fn into_expand(self, scope: &Scope) -> <(P0, P1, P2) as IntoExpand>::Expand

impl<P0, P1> IntoExpand for (P0, P1)

where P0: IntoExpand, P1: IntoExpand,

type Expand = (<P0 as IntoExpand>::Expand, <P1 as IntoExpand>::Expand)

fn into_expand(self, scope: &Scope) -> <(P0, P1) as IntoExpand>::Expand

impl<P0> IntoExpand for (P0,)

where P0: IntoExpand,

type Expand = (<P0 as IntoExpand>::Expand,)

fn into_expand(self, scope: &Scope) -> <(P0,) as IntoExpand>::Expand

impl<T, C, S, V> IntoExpand for VirtualViewExpand<T, C, S, V>

where T: CubePrimitive, C: Coordinates, S: Coordinates, V: ViewOperations<T, S>,

type Expand = VirtualViewExpand<T, C, S, V>

fn into_expand(self, _: &Scope) -> VirtualViewExpand<T, C, S, V>

impl<T, C, S, V> IntoExpand for VirtualViewMutExpand<T, C, S, V>

where T: CubePrimitive, C: Coordinates, S: Coordinates, V: ViewOperationsMut<T, S>,

type Expand = VirtualViewMutExpand<T, C, S, V>

fn into_expand(self, _: &Scope) -> VirtualViewMutExpand<T, C, S, V>

impl<T> IntoExpand for *const T

where T: IntoExpand<Expand = T> + ?Sized,

type Expand = *const T

fn into_expand(self, _: &Scope) -> <*const T as IntoExpand>::Expand

impl<T> IntoExpand for *mut T

where T: IntoExpand<Expand = T> + ?Sized,

type Expand = *mut T

fn into_expand(self, _: &Scope) -> <*mut T as IntoExpand>::Expand

impl<T> IntoExpand for Option<T>

where T: CubeType + IntoRuntime + Default,

type Expand = <Option<T> as CubeType>::ExpandType

fn into_expand(self, scope: &Scope) -> <Option<T> as IntoExpand>::Expand

Implementors

impl IntoExpand for Im2colExpand

type Expand = Im2colExpand

impl IntoExpand for Im2colWideExpand

type Expand = Im2colWideExpand

impl IntoExpand for InputScalarExpand

type Expand = InputScalarExpand

impl IntoExpand for MatrixLayout

type Expand = MatrixLayout

impl IntoExpand for OrderingExpand

type Expand = OrderingExpand

impl IntoExpand for RangeFullExpand

type Expand = RangeFullExpand

impl IntoExpand for TensorMetaExpand

type Expand = TensorMetaExpand

impl IntoExpand for TiledExpand

type Expand = TiledExpand

impl IntoExpand for e2m1

type Expand = NativeExpand<e2m1>

impl IntoExpand for e2m3

type Expand = NativeExpand<e2m3>

impl IntoExpand for e2m1x2

type Expand = NativeExpand<e2m1x2>

impl IntoExpand for e3m2

type Expand = NativeExpand<e3m2>

impl IntoExpand for e4m3

type Expand = NativeExpand<e4m3>

impl IntoExpand for e5m2

type Expand = NativeExpand<e5m2>

impl IntoExpand for flex32

type Expand = NativeExpand<flex32>

impl IntoExpand for tf32

type Expand = NativeExpand<tf32>

impl IntoExpand for ue8m0

type Expand = NativeExpand<ue8m0>

impl<A, B, CD> IntoExpand for MmaDefinitionExpand<A, B, CD>

where A: CubeType, B: CubeType, CD: CubeType,

type Expand = MmaDefinitionExpand<A, B, CD>

impl<C, S> IntoExpand for MatrixExpand<C, S>

where C: CubeType, S: MatrixScope,

type Expand = MatrixExpand<C, S>

impl<Idx> IntoExpand for RangeExpand<Idx>

where Idx: Scalar,

type Expand = RangeExpand<Idx>

impl<Idx> IntoExpand for RangeFromExpand<Idx>

where Idx: Scalar,

type Expand = RangeFromExpand<Idx>

impl<Idx> IntoExpand for RangeInclusiveExpand<Idx>

where Idx: Scalar,

type Expand = RangeInclusiveExpand<Idx>

impl<Idx> IntoExpand for RangeToExpand<Idx>

where Idx: Scalar,

type Expand = RangeToExpand<Idx>

impl<Idx> IntoExpand for RangeToInclusiveExpand<Idx>

where Idx: Scalar,

type Expand = RangeToInclusiveExpand<Idx>

impl<K, V> IntoExpand for Registry<K, V>

type Expand = Registry<K, V>

impl<Marker> IntoExpand for DynamicScalar<Marker>

where Marker: 'static,

type Expand = NativeExpand<DynamicScalar<Marker>>

impl<T, N> IntoExpand for Vector<T, N>

where T: Scalar + IntoExpand, N: Size,

type Expand = NativeExpand<Vector<T, N>>

impl<T> IntoExpand for ComptimeCellExpand<T>

where T: CubeType,

type Expand = ComptimeCellExpand<T>

impl<T> IntoExpand for ComptimeOptionExpand<T>

where T: CubeType,

type Expand = ComptimeOptionExpand<T>

impl<T> IntoExpand for NativeExpand<T>

where T: ?Sized,

type Expand = NativeExpand<T>

impl<T> IntoExpand for OptionExpand<T>

where T: CubeType,

type Expand = OptionExpand<T>

impl<T> IntoExpand for OwnedTensorExpand<T>

where T: CubePrimitive,

type Expand = OwnedTensorExpand<T>

impl<T> IntoExpand for RuntimeCellExpand<T>

where T: CubeType,

type Expand = RuntimeCellExpand<T>

impl<T> IntoExpand for SequenceExpand<T>

where T: CubeType,

type Expand = SequenceExpand<T>

impl<T> IntoExpand for TensorExpand<T>

where T: CubePrimitive,

type Expand = TensorExpand<T>

impl<T> IntoExpand for TensorViewBuilderExpand<T>

where T: CubePrimitive,

type Expand = TensorViewBuilderExpand<T>

impl<T> IntoExpand for TensorViewExpand<T>

where T: CubePrimitive,

type Expand = TensorViewExpand<T>

impl<T> IntoExpand for Vec<T>

where T: IntoExpand,

type Expand = Vec<T>