Struct kailua_types::ty::SpannedSlotSeq

pub struct SpannedSlotSeq {
    pub head: Vec<Spanned<Slot>>,
    pub tail: Option<Spanned<Slot>>,
    pub span: Span,
}

A sequence of spanned slot types. The sequence itself also contains its span.

Fields

head: Vec<Spanned<Slot>>

The "head" types, a list of finite types at the beginning of the sequence.

tail: Option<Spanned<Slot>>

The optional "tail" type. If present, it repeats indefinitely after "head".

This is implicitly nilable, because the actual value represented by the sequence is never infinite, so there should be a nil somewhere. Since we don't know where it ends, the tail should be implicitly unioned with nil in all practical sense.

We may implicitly put the nil here if it's missing, but the absence of the tail type makes a few important differences in checking. For example, function arguments are a sequence, and excess parameters to non-variadic arguments should be forbidden even if those excess parameters are always nil. This is only possible when we have a separate way to mark a missing tail.

span: Span

A span of the entire sequence. Used for finer diagnostics.

Methods

impl SpannedSlotSeq

fn new(span: Span) -> SpannedSlotSeq

fn from_seq(seq: SpannedTySeq) -> SpannedSlotSeq

fn dummy() -> SpannedSlotSeq

fn ensure_at(&mut self, i: usize) -> &Spanned<Slot>

fn ensure_at_mut(&mut self, i: usize) -> &mut Spanned<Slot>

fn ensure_tail(self) -> Self

fn into_iter(self) -> SeqIter<Spanned<Slot>>

fn into_iter_with_none(
    self
) -> Chain<Map<SeqIter<Spanned<Slot>>, fn(_: Spanned<Slot>) -> Option<Spanned<Slot>>>, Repeat<Option<Spanned<Slot>>>>

fn into_iter_with_nil(
    self
) -> Chain<SeqIter<Spanned<Slot>>, Repeat<Spanned<Slot>>>

fn into_first(self) -> Spanned<Slot>

fn unlift(self) -> SpannedTySeq

impl SpannedSlotSeq

fn unspan(self) -> SlotSeq

fn all_span(&self) -> Span

fn all_with_loc<Loc: Into<Span>>(self, loc: Loc) -> SpannedSlotSeq

fn all_without_loc(self) -> SpannedSlotSeq

Trait Implementations

impl Clone for SpannedSlotSeq

fn clone(&self) -> SpannedSlotSeq

Returns a copy of the value.

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

Performs copy-assignment from source.

impl PartialEq for SpannedSlotSeq

fn eq(&self, __arg_0: &SpannedSlotSeq) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &SpannedSlotSeq) -> bool

This method tests for !=.

impl<'a> From<Spanned<T<'a>>> for SpannedSlotSeq

fn from(t: Spanned<T<'a>>) -> SpannedSlotSeq

Performs the conversion.

impl From<Spanned<Ty>> for SpannedSlotSeq

fn from(t: Spanned<Ty>) -> SpannedSlotSeq

Performs the conversion.

impl From<Spanned<Slot>> for SpannedSlotSeq

fn from(s: Spanned<Slot>) -> SpannedSlotSeq

Performs the conversion.

impl Dummy for SpannedSlotSeq

fn dummy() -> SpannedSlotSeq

Generates a dummy value.

impl Union for SpannedSlotSeq

type Output = SpannedSlotSeq

A type of the resulting type.

fn union(
    &self,
    other: &SpannedSlotSeq,
    explicit: bool,
    ctx: &mut TypeContext
) -> TypeResult<SpannedSlotSeq>

Calculates a union type of self and other, explicitly or implicitly.

impl Lattice for SpannedSlotSeq

fn assert_sub(
    &self,
    other: &SpannedSlotSeq,
    ctx: &mut TypeContext
) -> TypeResult<()>

Asserts that self is a consistent subtype of other under the type context.

fn assert_eq(
    &self,
    other: &SpannedSlotSeq,
    ctx: &mut TypeContext
) -> TypeResult<()>

Asserts that self is a consistent type equal to other under the type context.

impl Display for SpannedSlotSeq

fn fmt_displayed(&self, f: &mut Formatter, st: &DisplayState) -> Result

fn display<'b, C>(&'b self, ctx: C) -> Displayed<'b, Self, C>

impl Debug for SpannedSlotSeq

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

Formats the value using the given formatter.