Struct ElimCase

Source

pub struct ElimCase<Cases> {
    pub cases: Cases,
}

Expand description

A lazy pattern match reified as a Rust type.

expr is the expression being matched on, generally of some enum type Ty.

case represents the pattern match–it will generally be a structure with one field per constructor in Ty. The field should contain enough information to run the match arm for that constructor, given the information contained in the constructor arguments.

ty represents the return type of the match expression. It does not carry any runtime-relevant information, but is needed in order to simplify our trait definitions.

The intent is that you should not construct this structure directly, nor should you define or construct the Cases structure directly. Instead, to use this you are expected to wrap your enum declaration in a call to [make_case_elim!], as follows:

veloren_common::make_case_elim!(
    my_type_module,
    #[repr(u32)]
    #[derive(Clone,Copy)]
    pub enum MyType {
        Constr1 = 0,
        #[typed(pure)] Constr2(arg : u8) = 1,
        /* ..., */
    }
);

This macro automatically does a few things. First, it creates the enum type MyType in the current scope, as expected. Second, it creates a module named my_type_module in the current scope, into which it dumps a few things. In this case:

#[repr(u32)]
#[derive(Clone, Copy)]
pub enum MyType {
    Constr1 = 0,
    Constr2(u8) = 1,
    /* ..., */
}

mod my_type_module {
    use serde::{Deserialize, Serialize};

    /// The number of variants in this enum.
    pub const NUM_VARIANTS: usize = 2;

    /// An array of all the variant indices (in theory, this can be used by this or other
    /// macros in order to easily build up things like uniform random samplers).
    pub const ALL_INDICES: [u32; NUM_VARIANTS] = [0, 1];

    /// A convenience trait used to store a different type for each constructor in this
    /// pattern.
    pub trait PackedElim {
        type Constr1;
        type Constr2;
    }

    /// The actual *cases.*  If you think of pattern match arms as being closures that accept
    /// the constructor types as arguments, you can think of this structure as somehow
    /// representing just the data *owned* by the closure.  This is also what you will
    /// generally store in your ron file--it has a field for each constructor of your enum,
    /// with the types of all the fields specified by the implementation of [PackedElim] for
    /// the [Elim] argument.  Each field has the same name as the constructor it represents.
    #[derive(Serialize, Deserialize)]
    pub struct Cases<Elim: PackedElim> {
        pub Constr1: Elim::Constr1,
        pub Constr2: Elim::Constr2,
    }

    /// Finally, because it represents by an overwhelming margin the most common usecase, we
    /// predefine a particular pattern matching strategy--"pure"--where every arm holds data of
    /// the exact same type, T.
    impl<T> PackedElim for veloren_common::typed::Pure<T> {
        type Constr1 = T;
        type Constr2 = T;
    }

    /// Because PureCases is so convenient, we have an alias for it.  Thus, in order to
    /// represent a pattern match on an argument that returns a constant of type (u8,u8,u8) for
    /// each arm, you'd use the type `PureCases<(u8, u8, u8)>`.
    pub type PureCases<Elim> = Cases<veloren_common::typed::Pure<Elim>>;
}

Finally, a useful implementation of the Typed trait completes this story, providing a way to evaluate this lazy math statement within Rust. Unfortunately, Typed is quite complicated, and this story is still being fully evaluated, so showing teh type may not be that elucidating. Instead, we’ll just present the method you can use most easily to pattern match using the PureCases pattern we mentioned earlier:

pub fn elim_case_pure<’a, Type>(&’a self, cases: &’a $mod::PureCases) -> &’a Type

If self is expression of your defined enum type, and match data defined by PureCases, this evaluates the pattern match on self and returns the matched case.

To see how this is used in more detail, check out common/src/body/humanoid.rs; it is also used extensively in the world repository.

Limitations:

Unfortunately, due to restrictions on macro_rules, we currently always require the types defined to #[repr(inttype)] as you can see above. There are also some other current limitations that we hopefully will be able to lift at some point; struct variants are not yet supported, and neither attributes on fields.

Fields§

§cases: Cases

Struct ElimCaseCopy item path

Fields§

Trait Implementations§

impl<'de, Cases> Deserialize<'de> for ElimCase<Cases>where Cases: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

impl<Cases> Serialize for ElimCase<Cases>where Cases: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

fn reduce(self, ((head), context): ((&'a BlockKind,), Context)) -> (Type, S)

impl<'a, 'b, Elim: PackedElim, Context, Type, S> Typed<((&'a BodyType,), Context), Type, S> for &'b ElimCase<Cases<Elim>>where &'b Elim::Female: Typed<Context, Type, S>, &'b Elim::Male: Typed<Context, Type, S>,

fn reduce(self, ((head), context): ((&'a BodyType,), Context)) -> (Type, S)

fn reduce(self, ((head), context): ((&'a Category,), Context)) -> (Type, S)

fn reduce(self, ((head), context): ((&'a EyeColor,), Context)) -> (Type, S)

fn reduce(self, ((head), context): ((&'a Skin,), Context)) -> (Type, S)

fn reduce(self, ((head), context): ((&'a Species,), Context)) -> (Type, S)

fn reduce(self, ((head), context): ((&'a SpriteKind,), Context)) -> (Type, S)

fn reduce( self, ((head), context): ((&'a StructureBlock,), Context), ) -> (Type, S)

Auto Trait Implementations§

impl<Cases> Freeze for ElimCase<Cases>where Cases: Freeze,

impl<Cases> RefUnwindSafe for ElimCase<Cases>where Cases: RefUnwindSafe,

impl<Cases> Send for ElimCase<Cases>where Cases: Send,

impl<Cases> Sync for ElimCase<Cases>where Cases: Sync,

impl<Cases> Unpin for ElimCase<Cases>where Cases: Unpin,

impl<Cases> UnwindSafe for ElimCase<Cases>where Cases: UnwindSafe,

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>where F: FnOnce(&Self) -> bool,

impl<T> Pointable for T

const ALIGN: usize

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)

impl<T> Same for T

type Output = T

impl<Context> SubContext<Context> for Context

fn sub_context(self) -> Context

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<V, T> VZip<V> for Twhere V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where S: Into<Dispatch>,

fn with_current_subscriber(self) -> WithDispatch<Self>

impl<T> DeserializeOwned for Twhere T: for<'de> Deserialize<'de>,

impl<T> Event for Twhere T: Send + Sync + 'static,

impl<T> Resource for Twhere T: Any + Send + Sync,

impl<T> Storable for Twhere T: Send + Sync + 'static,

Struct ElimCase

impl<'de, Cases> Deserialize<'de> for ElimCase<Cases>
where Cases: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where __D: Deserializer<'de>,

impl<Cases> Serialize for ElimCase<Cases>
where Cases: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,

impl<'a, 'b, Elim: PackedElim, Context, Type, S> Typed<((&'a BodyType,), Context), Type, S> for &'b ElimCase<Cases<Elim>>
where &'b Elim::Female: Typed<Context, Type, S>, &'b Elim::Male: Typed<Context, Type, S>,

impl<Cases> Freeze for ElimCase<Cases>
where Cases: Freeze,

impl<Cases> RefUnwindSafe for ElimCase<Cases>
where Cases: RefUnwindSafe,

impl<Cases> Send for ElimCase<Cases>
where Cases: Send,

impl<Cases> Sync for ElimCase<Cases>
where Cases: Sync,

impl<Cases> Unpin for ElimCase<Cases>
where Cases: Unpin,

impl<Cases> UnwindSafe for ElimCase<Cases>
where Cases: UnwindSafe,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,

impl<T> Event for T
where T: Send + Sync + 'static,

impl<T> Resource for T
where T: Any + Send + Sync,

impl<T> Storable for T
where T: Send + Sync + 'static,