Struct ArrayType 

pub struct ArrayType {
    pub inner: TypeHandle,
    pub length: usize,
}

Fields

inner: TypeHandle

length: usize

Implementations

impl ArrayType

pub fn get(ctx: &Context, inner: TypeHandle, length: usize) -> TypedHandle<Self>

Get or create a new instance.

Trait Implementations

impl AlignedType for ArrayType

fn align(&self, ctx: &Context) -> usize

fn verify(_op: &dyn Type, _ctx: &Context) -> Result<()>

where Self: Sized,

impl Clone for ArrayType

fn clone(&self) -> ArrayType

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for ArrayType

impl Debug for ArrayType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl DestructurableTypeInterface for ArrayType

fn subelement_index_map( &self, _ctx: &Context, ) -> Option<HMap<AttrObj, TypeHandle>>

Destructures the type into subelements into a map of indices to types of subelements. Returns nothing if the type cannot be destructured.

fn type_at_index(&self, _ctx: &Context, _index: &AttrObj) -> TypeHandle

Indicates which type is held at the provided index, returning None if no type could be computed. While this can return information even when the type cannot be completely destructured, it must be coherent with the types returned by subelement_index_map when they exist.

fn verify(_op: &dyn Type, _ctx: &Context) -> Result<()>

where Self: Sized,

impl Eq for ArrayType

impl HasElementType for ArrayType

fn element_type(&self, ctx: &Context) -> Option<TypeHandle>

fn verify(_op: &dyn Type, _ctx: &Context) -> Result<()>

where Self: Sized,

impl Hash for ArrayType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IndexableType for ArrayType

fn indexed_type(&self, _ctx: &Context) -> TypeHandle

fn verify(_op: &dyn Type, _ctx: &Context) -> Result<()>

where Self: Sized,

impl MaybePackedType for ArrayType

fn packing_factor(&self, ctx: &Context) -> usize

fn verify(_op: &dyn Type, _ctx: &Context) -> Result<()>

where Self: Sized,

impl MaybeVectorizedType for ArrayType

fn vector_size(&self, ctx: &Context) -> usize

fn try_vector_size(&self, ctx: &Context) -> Option<usize>

fn verify(_op: &dyn Type, _ctx: &Context) -> Result<()>

where Self: Sized,

impl OperandNOfType<0, ArrayType> for StMatrixOp

impl OperandNOfType<0, ArrayType> for MmaManualOp

impl OperandNOfType<0, ArrayType> for MmaManualScaledOp

impl OperandNOfType<1, ArrayType> for MmaManualOp

impl OperandNOfType<1, ArrayType> for MmaManualScaledOp

impl OperandNOfType<2, ArrayType> for MmaManualOp

impl OperandNOfType<2, ArrayType> for MmaManualScaledOp

impl Parsable for ArrayType

type Arg = ()

Type of the argument that must be passed to the parser.

type Parsed = TypedHandle<ArrayType>

The type of the parsed entity.

fn parse<'__pliron_parse>( state_stream: &mut StateStream<'__pliron_parse>, arg: Self::Arg, ) -> ParseResult<'__pliron_parse, Self::Parsed>

Define a parser using existing combinators and call into on Parser::parse_stream to get the final ParseResult. Use state_stream.state as necessary.

fn parser<'a>( arg: Self::Arg, ) -> Box<dyn Parser<Stream<Stream<Stream<Stream<IteratorStream<CharIterator<'a>>, SourcePosition>>>, State<'a>>, Output = Self::Parsed, PartialState = ()> + 'a>

where Self::Parsed: 'a,

Get a parser combinator that can work on StateStream as its input.

impl PartialEq for ArrayType

fn eq(&self, other: &ArrayType) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Printable for ArrayType

fn fmt(&self, ctx: &Context, state: &State, fmt: &mut Formatter<'_>) -> Result

fn disp<'t, 'c>(&'t self, ctx: &'c Context) -> Box<dyn Display + 'c>

where 't: 'c,

Get a Display’able object from the given Context and default State.

fn print<'t, 'c>( &'t self, ctx: &'c Context, state: &State, ) -> Box<dyn Display + 'c>

where 't: 'c,

Get a Display’able object from the given Context and State.

impl SizedType for ArrayType

fn size(&self, ctx: &Context) -> usize

fn verify(_op: &dyn Type, _ctx: &Context) -> Result<()>

where Self: Sized,

fn size_bits(&self, ctx: &Context) -> usize

impl StructuralPartialEq for ArrayType

impl Type for ArrayType

fn hash_type(&self) -> TypeValueHash

Compute and get the hash for this instance of Self. Hash collisions can be a possibility.

fn eq_type(&self, other: &dyn Type) -> bool

Is self equal to an other Type?

fn get_type_id(&self) -> TypeId

Get a Type’s static name. This is not per instantiation of the type. It is mostly useful for printing and parsing the type. Uniquing does not use this, but instead uses core::any::TypeId.

fn get_type_id_static() -> TypeId

Same as get_type_id, but without the self reference.

fn get_self_handle(&self, ctx: &Context) -> TypeHandle

Get a copyable handle to this type.

fn instantiate(t: Self, ctx: &Context) -> TypedHandle<Self>

where Self: Sized,

Instantiate a type in the provided Context, returning a TypeHandle to self.

fn register(ctx: &mut Context)

where Self: Sized + Parsable<Arg = (), Parsed = TypedHandle<Self>>,

Register this Type’s TypeId in the dialect it belongs to.

impl Verify for ArrayType

fn verify(&self, _ctx: &Context) -> Result<()>