uniplate 0.4.6

Simple, boilerplate-free operations on tree-shaped data types
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! Specialisation helpers for biplate.
use std::any::TypeId;

/// Specialization proxy for [`uniplate::Biplate`].
pub trait BiplateYes {
    /// The source type.
    type Src;
    /// The destination type of the biplate operation.
    type Dest: Eq + Clone;

    /// Calls `Biplate<Dest>` on the inner value.
    ///
    /// This method is called when the wrapped type implements `Biplate<Dest>`.
    fn spez_try_biplate(&self) -> (Tree<Self::Dest>, Box<dyn Fn(Tree<Self::Dest>) -> Self::Src>);

    #[allow(missing_docs)]
    fn spez_impls_biplate(&self) -> bool;
}

/// Specialization proxy for [`uniplate::Biplate`].
pub trait BiplateNo {
    /// The source type.
    type Src;
    /// The destination type of the biplate operation.
    type Dest: Eq + Clone;

    /// Fallback implementation used when the inner value doesn't implement `Biplate<Dest>`.
    fn spez_try_biplate(&self) -> (Tree<Self::Dest>, Box<dyn Fn(Tree<Self::Dest>) -> Self::Src>);

    #[allow(missing_docs)]
    fn spez_impls_biplate(&self) -> bool;
}

// Implementation of specialisation.

impl<Src, Dest> BiplateYes for &SpezBiplate<Src, Dest>
where
    Src: Biplate<Dest>,
    Dest: Eq + Clone + Uniplate,
{
    type Src = Src;
    type Dest = Dest;

    fn spez_try_biplate(&self) -> (Tree<Self::Dest>, Box<dyn Fn(Tree<Self::Dest>) -> Self::Src>) {
        self.0.biplate()
    }

    #[inline(always)]
    fn spez_impls_biplate(&self) -> bool {
        true
    }
}

impl<Src, Dest> BiplateNo for SpezBiplate<Src, Dest>
where
    Src: Eq + Clone + 'static,
    Dest: Eq + Clone + 'static,
{
    type Src = Src;
    type Dest = Dest;

    fn spez_try_biplate(&self) -> (Tree<Self::Dest>, Box<dyn Fn(Tree<Self::Dest>) -> Self::Src>) {
        // Biplate<T> for T returns self, not immediate childreen
        if TypeId::of::<Src>() == TypeId::of::<Dest>() {
            unsafe {
                let this_as_dest: Dest = (std::mem::transmute::<&Src, &Dest>(&self.0)).clone();

                let tree = Tree::One(this_as_dest);
                let ctx = Box::new(move |x| {
                    let Tree::One(x) = x else {
                        panic!();
                    };

                    std::mem::transmute::<&Dest, &Src>(&x).clone()
                });

                (tree, ctx)
            }
        } else {
            let this = self.0.clone();
            (Tree::Zero, Box::new(move |_| this.clone()))
        }
    }

    #[inline(always)]
    fn spez_impls_biplate(&self) -> bool {
        false
    }
}

#[doc(inline)]
/// Tries to call `Biplate<$t>::biplate` on `$x`, returning a default implementation if `$x` does
/// not implement `Biplate<$t>`.
pub use crate::try_biplate_to;

#[macro_export]
#[doc(hidden)]
macro_rules! try_biplate_to {
    ($x:expr,$t:ty) => {{
        #[allow(unused_imports)]
        use ::uniplate::spez::{BiplateNo, BiplateYes, SpezBiplate};
        #[allow(clippy::needless_borrow)]
        (&&SpezBiplate($x, std::marker::PhantomData::<$t>)).spez_try_biplate()
    }};
}

use crate::Biplate;
use crate::Tree;
use crate::Uniplate;
#[doc(inline)]
/// Returns whether `x` implements `Biplate<$t>`.
///
/// ```
/// use uniplate::{spez::impls_biplate_to,Uniplate};
///
/// #[derive(Clone,PartialEq,Eq,Uniplate)]
/// #[biplate(to=String)]
/// enum Expr {
///  A(String)
/// }
///
/// assert!(!impls_biplate_to!(String::from("foo"),i32));
/// assert!(impls_biplate_to!(String::from("foo"),String));
/// assert!(impls_biplate_to!(Expr::A(String::from("foo")),String));
/// ```
pub use crate::impls_biplate_to;

use super::SpezBiplate;

#[macro_export]
#[doc(hidden)]
macro_rules! impls_biplate_to {
    ($x:expr,$t:ty) => {{
        #[allow(unused_imports)]
        use ::uniplate::spez::{BiplateNo as _, BiplateYes as _, SpezBiplate};
        #[allow(clippy::needless_borrow)]
        (&&SpezBiplate($x, std::marker::PhantomData::<$t>)).spez_impls_biplate()
    }};
}