1pub use derive_refineable::Refineable;
 2
 3pub trait Refineable: Clone {
 4    type Refinement: Refineable<Refinement = Self::Refinement> + Default;
 5
 6    fn refine(&mut self, refinement: &Self::Refinement);
 7    fn refined(mut self, refinement: &Self::Refinement) -> Self
 8    where
 9        Self: Sized,
10    {
11        self.refine(refinement);
12        self
13    }
14    fn from_refinement(refinement: &Self::Refinement) -> Self
15    where
16        Self: Default + Sized,
17    {
18        Self::default().refined(refinement)
19    }
20    fn from_cascade(cascade: &Cascade<Self>) -> Self
21    where
22        Self: Default + Sized,
23    {
24        Self::default().refined(&cascade.merged())
25    }
26}
27
28pub struct Cascade<S: Refineable>(Vec<Option<S::Refinement>>);
29
30impl<S: Refineable + Default> Default for Cascade<S> {
31    fn default() -> Self {
32        Self(vec![Some(Default::default())])
33    }
34}
35
36#[derive(Copy, Clone)]
37pub struct CascadeSlot(usize);
38
39impl<S: Refineable + Default> Cascade<S> {
40    pub fn reserve(&mut self) -> CascadeSlot {
41        self.0.push(None);
42        return CascadeSlot(self.0.len() - 1);
43    }
44
45    pub fn base(&mut self) -> &mut S::Refinement {
46        self.0[0].as_mut().unwrap()
47    }
48
49    pub fn set(&mut self, slot: CascadeSlot, refinement: Option<S::Refinement>) {
50        self.0[slot.0] = refinement
51    }
52
53    pub fn merged(&self) -> S::Refinement {
54        let mut merged = self.0[0].clone().unwrap();
55        for refinement in self.0.iter().skip(1) {
56            if let Some(refinement) = refinement {
57                merged.refine(refinement);
58            }
59        }
60        merged
61    }
62}