yarnspinner_core 0.8.0

Core concepts for Yarn Spinner for Rust, the friendly tool for writing game dialogue
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

//! Marker traits for [`super::YarnFnParam`] to determine if the type is [`Required`] or
//! [`Optional`].
#![allow(missing_debug_implementations)]

use variadics_please::all_tuples;

/// Marker trait for valid optionality hints.
pub trait Optionality: private::Sealed {}

/// An optional parameter or a tuple where
/// the last element is optional.
pub struct Optional;

impl private::Sealed for Optional {}
impl Optionality for Optional {}

/// A parameter that is required.
pub struct Required;

impl private::Sealed for Required {}
impl Optionality for Required {}

mod private {
    /// Used to seal [`AllowedOptionalityChain`] so the type can be exported,
    /// but not implemented.
    pub trait Sealed {}
}

/// A valid chain of optionality hints
/// i.e. a chain where no optional element follows
/// a required element.
pub trait AllowedOptionalityChain: private::Sealed {
    /// The optionality hint of the last element in the chain.
    type Last: Optionality;
}

impl private::Sealed for () {}
impl AllowedOptionalityChain for () {
    type Last = Required;
}

impl<O: Optionality> private::Sealed for (O,) {}
impl<O: Optionality> AllowedOptionalityChain for (O,) {
    type Last = O;
}

impl<O: Optionality> private::Sealed for (Required, O) {}
impl<O: Optionality> AllowedOptionalityChain for (Required, O) {
    type Last = O;
}

impl private::Sealed for (Optional, Optional) {}
impl AllowedOptionalityChain for (Optional, Optional) {
    type Last = Optional;
}

// `impl AllowedOptionalityChain for (Optional, Required) {}`
// is intentionally missing (that's the whole point of this trait).

macro_rules! impl_chain {
    // Implementations for zero, one and two-element tuples covered manually.
    () => {};
    ($p1:ident) => {};
    ($p1:ident, $p2:ident) => {};
    ($($param:ident),*) => {
        // A tuple of three or more elements is valid
        // if all two-pairs from left to right are valid.
        // example: (A, B, C) is valid if (A, B) and (B, C) are.
        impl_chain!(@pairwise [$($param),*] [] $($param,)*);
    };
    (@pairwise [$($param:ident),*] [$($tt:tt)*] $a:ident, $b:ident,) => {
        impl_chain!(@emit [$($param),*] [$($tt)* ($a, $b): AllowedOptionalityChain,] $b,);
    };
    (@pairwise [$($param:ident),*] [$($tt:tt)*] $a:ident, $b:ident, $($tail:ident,)*) => {
        impl_chain!(@pairwise [$($param),*] [$($tt)* ($a, $b): AllowedOptionalityChain,] $b, $($tail,)*);
    };
    (@emit [$($param: ident),*] [$($tt:tt)*] $last:ident,) => {
        impl<$($param: Optionality),*> private::Sealed for ($($param),*) where $($tt)* {}
        impl<$($param: Optionality),*> AllowedOptionalityChain for ($($param),*) where $($tt)* {
            type Last = $last;
        }
    };
}

all_tuples!(impl_chain, 0, 16, O);