purescript_waterslide 0.3.1

Generate Purescript types from your Rust 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

use purs_constructor::*;

impl<T: AsPursConstructor> AsPursConstructor for Vec<T> {
    fn as_purs_constructor() -> PursConstructor {
        PursConstructor {
            name: "Array".to_string(),
            module: None,
            parameters: vec![<T as AsPursConstructor>::as_purs_constructor()],
        }
    }
}

impl<'a, T: AsPursConstructor> AsPursConstructor for &'a [T] {
    fn as_purs_constructor() -> PursConstructor {
        PursConstructor {
            name: "Array".to_string(),
            module: None,
            parameters: vec![<T as AsPursConstructor>::as_purs_constructor()],
        }
    }
}

impl<T: AsPursConstructor> AsPursConstructor for Option<T> {
    fn as_purs_constructor() -> PursConstructor {
        PursConstructor {
            name: "Maybe".to_string(),
            module: Some("Data.Maybe".to_string()),
            parameters: vec![<T as AsPursConstructor>::as_purs_constructor()],
        }
    }
}

impl<'a> AsPursConstructor for &'a str {
    fn as_purs_constructor() -> PursConstructor {
        PursConstructor {
            name: "String".to_string(),
            module: None,
            parameters: vec![],
        }
    }
}

impl<T, U> AsPursConstructor for (T, U)
where
    T: AsPursConstructor,
    U: AsPursConstructor,
{
    fn as_purs_constructor() -> PursConstructor {
        PursConstructor {
            name: "Tuple".to_string(),
            module: Some("Data.Tuple".to_string()),
            parameters: vec![
                <T as AsPursConstructor>::as_purs_constructor(),
                <U as AsPursConstructor>::as_purs_constructor(),
            ],
        }
    }
}

impl AsPursConstructor for () {
    fn as_purs_constructor() -> PursConstructor {
        PursConstructor {
            module: Some("Prelude".to_string()),
            name: "Tuple".to_string(),
            parameters: vec![],
        }
    }
}

impl<T: AsPursConstructor> AsPursConstructor for Box<T> {
    fn as_purs_constructor() -> PursConstructor {
        T::as_purs_constructor()
    }
}

impl<'a, T: AsPursConstructor> AsPursConstructor for &'a T {
    fn as_purs_constructor() -> PursConstructor {
        T::as_purs_constructor()
    }
}

macro_rules! purs_primitive_impl {
    ($rust_type:ty, $purs_type:expr, $import:expr) => {
        impl AsPursConstructor for $rust_type {
            fn as_purs_constructor() -> PursConstructor {
                PursConstructor {
                    module: Some($import.to_string()),
                    name: $purs_type.to_string(),
                    parameters: vec![],
                }
            }
        }
    }
}

const PRIM: &'static str = "PRIM";

purs_primitive_impl!(bool, "Boolean", PRIM);

purs_primitive_impl!(i8, "Int", PRIM);
purs_primitive_impl!(i16, "Int", PRIM);
purs_primitive_impl!(i32, "Int", PRIM);
purs_primitive_impl!(i64, "Int", PRIM);
purs_primitive_impl!(isize, "Int", PRIM);

purs_primitive_impl!(u8, "Int", PRIM);
purs_primitive_impl!(u16, "Int", PRIM);
purs_primitive_impl!(u32, "Int", PRIM);
purs_primitive_impl!(u64, "Int", PRIM);
purs_primitive_impl!(usize, "Int", PRIM);

purs_primitive_impl!(f32, "Number", PRIM);
purs_primitive_impl!(f64, "Number", PRIM);

purs_primitive_impl!(String, "String", PRIM);