vpm 0.0.0

virtual package manager
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

use pretty::termcolor::{Color, ColorSpec};

use crate::{helpers::colored_text, Lispify};
use pretty::{Doc, RcDoc};

/// The lisp data structure
#[derive(Clone, Debug)]
pub enum Lisp {
    /// A normal list of lisp
    Any(Vec<Lisp>),
    /// Mark as a keyword
    Keyword(String),
    /// Mark as a function
    Function(String),
    /// Mark as a operator
    Operator(String),
    /// Mark as a number
    Number(Box<LispNumber>),
    /// Mark as a symbol
    Symbol(Box<LispSymbol>),
    /// Mark as a string
    String(Box<ListString>),
}

#[derive(Clone, Debug)]
pub struct ListString {
    pub text: String,
    pub unit: String,
}
impl From<ListString> for Lisp {
    fn from(value: ListString) -> Self {
        Lisp::String(Box::new(value))
    }
}
#[derive(Clone, Debug)]
pub struct LispNumber {
    pub number: String,
    pub unit: String,
}

impl From<LispSymbol> for Lisp {
    fn from(value: LispSymbol) -> Self {
        Lisp::Symbol(Box::new(value))
    }
}

#[derive(Clone, Debug)]
pub struct LispSymbol {
    pub name: String,
    pub path: Vec<String>,
}

impl From<LispNumber> for Lisp {
    fn from(value: LispNumber) -> Self {
        Lisp::Number(Box::new(value))
    }
}

impl LispSymbol {
    pub fn new<S: ToString>(name: S) -> Self {
        LispSymbol { name: name.to_string(), path: vec![] }
    }

    pub(crate) fn to_doc(&self) -> RcDoc<ColorSpec> {
        let mut term = colored_text(&self.name, Color::Red);
        for symbol in &self.path {
            let new = colored_text(symbol, Color::Red);
            term = term.append(RcDoc::text("∷")).append(new)
        }
        term
    }
}

impl LispNumber {
    pub(crate) fn to_doc(&self) -> RcDoc<ColorSpec> {
        let n = RcDoc::text(&self.number).annotate(ColorSpec::new().set_fg(Some(Color::Red)).clone());
        if self.unit.is_empty() {
            n
        }
        else {
            let unit = RcDoc::text(&self.unit).annotate(ColorSpec::new().set_fg(Some(Color::Cyan)).clone());
            n.append(unit)
        }
    }
}

impl ListString {
    pub(crate) fn to_doc(&self) -> RcDoc<ColorSpec> {
        let n = colored_text(&self.text, Color::Green);
        if self.unit.is_empty() {
            n
        }
        else {
            let unit = colored_text(&self.unit, Color::Cyan);
            unit.append(n)
        }
    }
}

impl Lisp {
    pub fn keyword<S: ToString>(name: S) -> Self {
        Lisp::Keyword(name.to_string())
    }
    pub fn function<S: ToString>(name: S) -> Self {
        Lisp::Function(name.to_string())
    }
    pub fn operator<S: ToString, T: Lispify>(name: S, arguments: &[T]) -> Self {
        let head = Lisp::Operator(name.to_string());
        let mut terms = Vec::with_capacity(arguments.len() + 1);
        terms.push(head);
        terms.extend(arguments.iter().map(|x| x.lispify().into()));
        Lisp::Any(terms)
    }

    pub(crate) fn to_doc(&self) -> RcDoc<ColorSpec> {
        match self {
            Lisp::Any(xs) => RcDoc::text("(")
                .append(RcDoc::intersperse(xs.into_iter().map(|x| x.to_doc()), Doc::line()).nest(2).group())
                .append(RcDoc::text(")")),
            Lisp::Keyword(v) => colored_text(v, Color::Magenta),
            Lisp::Operator(v) => colored_text(v, Color::Blue),
            Lisp::Function(v) => colored_text(v, Color::Blue),
            Lisp::Symbol(v) => v.to_doc(),
            Lisp::String(v) => v.to_doc(),
            Lisp::Number(x) => x.to_doc(),
        }
    }
}