Struct SliceType 

pub struct SliceType {
    pub base_ty: TypeHandle,
}

Fields

base_ty: TypeHandle

Implementations

impl SliceType

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

Get or create a new instance.

Trait Implementations

impl Clone for SliceType

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SliceType

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

Formats the value using the given formatter.

impl DestructurableTypeInterface for SliceType

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 SliceType

impl Hash for SliceType

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 Parsable for SliceType

type Arg = ()

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

type Parsed = TypedHandle<SliceType>

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 SliceType

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

Equality operator ==.

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

Inequality operator !=.

impl Printable for SliceType

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 StructuralPartialEq for SliceType

impl Type for SliceType

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 TypeImplsInterface<dyn DestructurableTypeInterface> for SliceType

impl Verify for SliceType

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