lambdust 0.1.1

A Scheme dialect with gradual typing and effect systems
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

//! Formal parameters for lambda expressions.

use crate::diagnostics::Spanned;
use serde::{Deserialize, Serialize};
use std::fmt;

use super::Expr;

/// Formal parameters for lambda expressions.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum Formals {
    /// Fixed number of parameters: (param1 param2 ...)
    Fixed(Vec<String>),
    /// Variable parameters: param (all arguments collected into param)
    Variable(String),
    /// Mixed parameters: (param1 param2 . rest)
    Mixed {
        fixed: Vec<String>,
        rest: String,
    },
    /// Keyword parameters: (param1 param2 #:key1 default1 ...)
    Keyword {
        fixed: Vec<String>,
        rest: Option<String>,
        keywords: Vec<KeywordParam>,
    },
}

/// A keyword parameter with optional default value.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct KeywordParam {
    pub name: String,
    pub default: Option<Spanned<Expr>>,
}

impl fmt::Display for Formals {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Formals::Fixed(params) => {
                write!(f, "(")?;
                for (i, param) in params.iter().enumerate() {
                    if i > 0 { write!(f, " ")?; }
                    write!(f, "{param}")?;
                }
                write!(f, ")")
            }
            Formals::Variable(param) => write!(f, "{param}"),
            Formals::Mixed { fixed, rest } => {
                write!(f, "(")?;
                for (i, param) in fixed.iter().enumerate() {
                    if i > 0 { write!(f, " ")?; }
                    write!(f, "{param}")?;
                }
                write!(f, " . {rest})")
            }
            Formals::Keyword { fixed, rest, keywords } => {
                write!(f, "(")?;
                for (i, param) in fixed.iter().enumerate() {
                    if i > 0 { write!(f, " ")?; }
                    write!(f, "{param}")?;
                }
                if let Some(rest) = rest {
                    if !fixed.is_empty() { write!(f, " ")?; }
                    write!(f, ". {rest}")?;
                }
                for kw in keywords {
                    write!(f, " #{} {}", kw.name, kw.name)?;
                    if let Some(default) = &kw.default {
                        write!(f, " {}", default.inner)?;
                    }
                }
                write!(f, ")")
            }
        }
    }
}