windjammer 0.48.0

A simple language inspired by Go, Ruby, and Elixir that transpiles to Rust - 80% of Rust's power with 20% of the complexity
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

//! Format Windjammer [`Type`] values for IDE/MCP output.

use crate::parser::ast::types::Type;

/// Render a Windjammer type as a human-readable string (matches parser conventions).
pub fn format_wj_type(ty: &Type) -> String {
    match ty {
        Type::Int => "int".to_string(),
        Type::Int32 => "i32".to_string(),
        Type::Uint => "uint".to_string(),
        Type::Float => "float".to_string(),
        Type::Bool => "bool".to_string(),
        Type::String => "string".to_string(),
        Type::Custom(name) | Type::Generic(name) => name.clone(),
        Type::Reference(inner) => format!("&{}", format_wj_type(inner)),
        Type::MutableReference(inner) => format!("&mut {}", format_wj_type(inner)),
        Type::RawPointer { mutable, pointee } => {
            if *mutable {
                format!("*mut {}", format_wj_type(pointee))
            } else {
                format!("*const {}", format_wj_type(pointee))
            }
        }
        Type::Option(inner) => format!("Option<{}>", format_wj_type(inner)),
        Type::Result(ok, err) => format!("Result<{}, {}>", format_wj_type(ok), format_wj_type(err)),
        Type::Vec(inner) => format!("Vec<{}>", format_wj_type(inner)),
        Type::Array(inner, size) => format!("[{}; {}]", format_wj_type(inner), size),
        Type::Tuple(types) => {
            let parts: Vec<String> = types.iter().map(format_wj_type).collect();
            format!("({})", parts.join(", "))
        }
        Type::Parameterized(base, args) => {
            let parts: Vec<String> = args.iter().map(format_wj_type).collect();
            format!("{}<{}>", base, parts.join(", "))
        }
        Type::Associated(base, name) => format!("{}::{}", base, name),
        Type::TraitObject(trait_name) => format!("dyn {}", trait_name),
        Type::ImplTrait(trait_name) => format!("trait {}", trait_name),
        Type::Infer => "_".to_string(),
        Type::FunctionPointer {
            params,
            return_type,
        } => {
            let param_strs: Vec<String> = params.iter().map(format_wj_type).collect();
            match return_type {
                Some(ret) => format!("fn({}) -> {}", param_strs.join(", "), format_wj_type(ret)),
                None => format!("fn({})", param_strs.join(", ")),
            }
        }
    }
}