Struct Cons

pub(crate) struct Cons(GcHeap<ConsInner>);

Tuple Fields

0: GcHeap<ConsInner>

Implementations

impl Cons

pub(crate) fn elements(&self) -> ElemIter<'_>

pub(crate) fn conses(&self) -> ConsIter<'_>

impl Cons

unsafe fn new_unchecked( car: Gc<ObjectType<'_>>, cdr: Gc<ObjectType<'_>>, ) -> ConsInner

pub(crate) fn new<'ob, T, Tx, U, Ux, const C: bool>( car: T, cdr: U, cx: &'ob Block<C>, ) -> &'ob Self

where T: IntoObject<Out<'ob> = Tx>, Gc<Tx>: Into<Gc<ObjectType<'ob>>>, U: IntoObject<Out<'ob> = Ux>, Gc<Ux>: Into<Gc<ObjectType<'ob>>>,

Create a new cons cell

pub(crate) fn new1<'ob, T, Tx, const C: bool>( car: T, cx: &'ob Block<C>, ) -> &'ob Self

where T: IntoObject<Out<'ob> = Tx>, Gc<Tx>: Into<Gc<ObjectType<'ob>>>,

Create a new cons cell with the cdr set to nil

pub(super) fn mark_const(&mut self)

impl Cons

pub(super) fn display_walk( &self, f: &mut Formatter<'_>, seen: &mut HashSet<*const u8>, ) -> Result

fn is_backref(&self, seen: &mut HashSet<*const u8>) -> bool

Methods from Deref<Target = GcHeap<ConsInner>>

const NULL: *mut u8 = {0x0 as *mut u8}

const EMTPTY: AtomicPtr<u8> = _

fn header(&self) -> &GcHeader

pub(in core) fn forward( &self, fwd_ptr: NonNull<u8>, )

pub(in core) fn allocation_state( &self, ) -> AllocState

fn is_marked(&self) -> bool

Trait Implementations

impl<'new> CloneIn<'new, &'new Cons> for Cons

fn clone_in<const C: bool>(&self, bk: &'new Block<C>) -> Gc<&'new Cons>

impl<'ob> IntoIterator for &'ob Cons

type Item = <ElemIter<'ob> as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = ElemIter<'ob>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoObject for Cons

type Out<'ob> = &'ob Cons

fn into_obj<const C: bool>(self, block: &Block<C>) -> Gc<Self::Out<'_>>

impl Markable for Cons

type Value = NonNull<Cons>

fn move_value(&self, to_space: &Bump) -> Option<(Self::Value, bool)>

impl PartialEq for Cons

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RootedDeref for Cons

type Target = RootedCons

fn rooted_deref(rooted: &Rt<Self>) -> &Self::Target

fn rooted_derefmut(rooted: &mut Rt<Self>) -> &mut Self::Target

impl TaggedPtr for &Cons

const TAG: Tag = Tag::Cons

Tag value. This is only applicable to base values. Use Int for sum types.

type Ptr = Cons

The type of object being pointed to. This will be different for all implementors.

unsafe fn from_obj_ptr(ptr: *const u8) -> Self

Given an untyped pointer, reinterpret to self.

fn get_ptr(self) -> *const Self::Ptr

Get the underlying pointer.

unsafe fn tag_ptr(ptr: *const Self::Ptr) -> Gc<Self>

Given a pointer to Ptr return a Tagged pointer.

fn untag(val: Gc<Self>) -> Self

Remove the tag from the Gc<T> and return the inner type. If it is base type then it will only have a single possible value and can be untagged without checks, but sum types need to create all values they can hold. We use tagged base types to let us reinterpret bits without actually modify them.

fn tag(self) -> Gc<Self>

Given the type, return a tagged version of it. When using a sum type or an immediate value like i64, we override this method to set the proper tag.

impl Trace for Cons

fn trace(&self, state: &mut GcState)

impl<'ob> TryFrom<Gc<ObjectType<'ob>>> for &'ob Cons

type Error = TypeError

The type returned in the event of a conversion error.

fn try_from(obj: Gc<ObjectType<'ob>>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'old, 'new> WithLifetime<'new> for &'old Cons

type Out = &'new Cons

unsafe fn with_lifetime(self) -> Self::Out

impl<'ob> From<&'ob Cons> for Gc<FunctionType<'ob>>

fn from(x: &'ob Cons) -> Self

Converts to this type from the input type.

impl<'ob> From<&'ob Cons> for Gc<ListType<'ob>>

fn from(x: &'ob Cons) -> Self

Converts to this type from the input type.

impl<'ob> From<&'ob Cons> for Gc<ObjectType<'ob>>

fn from(x: &'ob Cons) -> Self

Converts to this type from the input type.

impl Debug for Cons

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

Formats the value using the given formatter.

impl Display for Cons

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

Formats the value using the given formatter.

impl Deref for Cons

type Target = GcHeap<ConsInner>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Eq for Cons

impl GcPtr for &Cons

impl StructuralPartialEq for Cons