specta 2.0.0-rc.9

Easily export your Rust types to other languages
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

use crate::*;

/// TODO
pub fn export<T: Type>() -> Result<String, String> {
    datatype(&T::definition(&mut TypeDefs::default())
}

fn datatype(t: &DataTypeExt) -> Result<String, String> {
    // TODO: This system does lossy type conversions. That is something I want to fix in the future but for now this works. Eg. `HashSet<T>` will be exported as `Vec<T>`
    // TODO: Serde serialize + deserialize on types

    Ok(match t.inner {
        DataType::Any => "serde_json::Value".to_owned(),
        DataType::Primitive(ty) => ty.to_rust_str().to_owned(),
        DataType::Literal(_) => todo!(),
        DataType::Nullable(t) => format!("Option<{}>", datatype(t)?),
        DataType::Map(t) => format!("HashMap<{}, {}>", datatype(&t.0)?, datatype(&t.1)?),
        DataType::List(t) => format!("Vec<{}>", datatype(t)?),
        DataType::Tuple(TupleType { fields, .. }) => match &fields[..] {
            [] => "()".to_string(),
            [ty] => datatype(ty)?,
            tys => format!(
                "({})",
                tys.iter()
                    .map(|v| datatype(v))
                    .collect::<Result<Vec<_>, _>>()?
                    .join(", ")
            ),
        },
        DataType::Struct(StructType {
            name,
            generics,
            fields,
            tag,
            ..
        }) => match &fields[..] {
            [] => "struct {name}".to_string(),
            fields => {
                let generics = (!generics.is_empty())
                    .then(|| format!("<{}>", generics.join(", ")))
                    .unwrap_or_default();

                let fields = fields
                    .iter()
                    .map(|f| {
                        let name = &f.name;
                        let typ = datatype(&f.ty)?;
                        Ok(format!("\t{name}: {typ}"))
                    })
                    .collect::<Result<Vec<_>, String>>()?
                    .join(", ");

                let tag = tag
                    .clone()
                    .map(|t| format!("{t}: String"))
                    .unwrap_or_default();

                format!("struct {name}{generics} {{ {fields}{tag} }}\n")
            }
        },
        DataType::Enum(_) => todo!(),
        DataType::Reference { name, generics, .. } => match &generics[..] {
            [] => name.to_string(),
            generics => {
                let generics = generics
                    .iter()
                    .map(datatype)
                    .collect::<Result<Vec<_>, _>>()?
                    .join(", ");

                format!("{name}<{generics}>")
            }
        },
        DataType::Generic(GenericType(t)) => t.to_string(),
    })
}