Struct Cons 

pub struct Cons<T, U>(pub T, pub U);

Prepends an element to the cons-list, somewhat equivalent to the array [T, ...U].

Tuple Fields

0: T

1: U

Implementations

impl<T, U> Cons<T, U>

pub(crate) fn project<'pin>( self: Pin<&'pin mut Self>, ) -> __ConsProjection<'pin, T, U>

pub(crate) fn project_ref<'pin>( self: Pin<&'pin Self>, ) -> __ConsProjectionRef<'pin, T, U>

Trait Implementations

impl<T, U> AccessCount for Cons<T, U>

where T: AccessKind, U: AccessCount,

fn writers(type_id: TypeId) -> usize

Returns how many writers for the given type exist in this list.

fn readers(type_id: TypeId) -> usize

Returns how many readers for the given type exist in this list (both exclusive and non-exclusive).

fn exclusive_readers(type_id: TypeId) -> usize

Returns how many exclusive readers for the given type exist in this list.

impl<'a, T, U> ActorList<'a> for Cons<T, U>

where T: Actor<'a, StoreRequest: TupleConsToCons>, U: ActorList<'a>, <<T as Actor<'a>>::StoreRequest as TupleConsToCons>::Cons: AccessCount,

type StoreRequests = Cons<<<T as Actor<'a>>::StoreRequest as TupleConsToCons>::Cons, <U as ActorList<'a>>::StoreRequests>

Actor::StoreRequest for the #[actor] generated types is a tuple-cons-list, for each actor in this list convert its store requests into our nominal cons-list.

This doesn’t work with manual Actor implementations that have non-tuple-cons-list StoreRequests.

type InitContexts = Cons<<T as Actor<'a>>::InitContext, <U as ActorList<'a>>::InitContexts>

For Actor::InitContext we just need to map directly to the associated type.

impl<T: Clone, U: Clone> Clone for Cons<T, U>

fn clone(&self) -> Cons<T, U>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Datastore for Cons<Source, S>

where S: Slots,

Given a slot cons-list, combines it with a generational::Source to implement Datastore.

fn source(self: Pin<&Self>) -> Pin<&Source>

Returns a generational source tracking the global datastore generation.

fn slot<T>(self: Pin<&Self>) -> Pin<&Slot<T>>

where T: Storable + 'static,

Returns a reference to the slot for a specific type.

impl<T: Debug, U: Debug> Debug for Cons<T, U>

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

Formats the value using the given formatter.

impl<T, R> IntoSlots for Cons<T, R>

where T: Storable + 'static, R: IntoSlots,

type Slots = Cons<Slot<T>, <R as IntoSlots>::Slots>

A cons-list that contains a slot for every type in this cons-list.

fn make_slots() -> Self::Slots

Creates a new instance of the slot cons-list with all slots empty.

impl<T, U> NestedAccessCount for Cons<T, U>

where T: AccessCount, U: NestedAccessCount,

fn writers(type_id: TypeId) -> usize

Returns how many writers for the given type exist in this list of lists.

fn readers(type_id: TypeId) -> usize

Returns how many readers for the given type exist in this list of lists (both exclusive and non-exclusive).

fn exclusive_readers(type_id: TypeId) -> usize

Returns how many exclusive readers for the given type exist in this list of lists.

impl<T: PartialEq, U: PartialEq> PartialEq for Cons<T, U>

fn eq(&self, other: &Cons<T, U>) -> 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<U, R> Slots for Cons<Slot<U>, R>

where U: Storable + 'static, R: Slots,

fn slot<T>(self: Pin<&Self>) -> Pin<&Slot<T>>

where T: Storable + 'static,

See Datastore::slot.

fn all_slots() -> impl Iterator<Item = (TypeId, &'static str)>

Returns the TypeId and type names for all the slots stored in this type.

impl<T: Copy, U: Copy> Copy for Cons<T, U>

impl<T: Eq, U: Eq> Eq for Cons<T, U>

impl<T, U> StructuralPartialEq for Cons<T, U>

impl<'pin, T, U> Unpin for Cons<T, U>

where PinnedFieldsOf<__Cons<'pin, T, U>>: Unpin,