impral 0.1.6

A command parsing and evaluation library for a LISP dialect, specialized for commandline input.
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
129
130

//! The abstract-syntax-tree.

use super::*;

/// A expression node.
#[derive(Clone, PartialEq)]
pub enum Expression {
    /// Nothing; an empty slot.
    Empty,
    
    /// A value.
    Value(Literal),
    
    /// A function call / command invocation.
    Invoke(Box<Invoke>),
    
    /// A range from START to END, maybe INCLUSIVE.
    Range(Box<Expression>, Box<Expression>, bool),
    
    /// A field/member access on the left expression.
    Field(Box<Expression>, CompactString),
    
    /// A index/array access on the left expression.
    Index(Box<Expression>, Box<Expression>),
    
    /// Unwrap the left expression; throwing an error if bool is `true`.
    Try(Box<Expression>, bool),
    
    /// A pipe / generator / iterator.
    Pipe(Box<Pipe>),
}

/// A (small)vec of expression nodes.
pub type ExpressionVec = SmallVec<[Expression; 1]>;

/// A command (-node) to be evaluated.
#[derive(Clone, Default, PartialEq)]
pub struct Invoke {
    /// The name of the command.
    pub name: CompactString,
    
    /// The positional arguments.
    ///
    /// As long as there is only one positional argument, there will be no direct heap allocation.
    pub pos_args: ExpressionVec,
    
    /// The nominal/named arguments.
    pub nom_args: FxHashMap<CompactString, Expression>,
}

/// A pipe.
#[derive(Clone, PartialEq)]
pub struct Pipe {
    /// The expression yielding pipe items.
    pub source: Expression,
    
    /// The segments of the pipe.
    pub stages: Vec<PipeSeg>,
}

/// A segment of a pipe.
#[derive(Clone, PartialEq)]
pub struct PipeSeg {
    /// If true, the invoke result is used as filter.
    pub filter: bool,
    
    /// This segments invoke.
    pub invoke: Expression,
}

// ----------------------------------------------------------------------------



impl std::fmt::Debug for Expression {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Expression::Empty => write!(f, "_"),
            Expression::Value(l) => std::fmt::Debug::fmt(l, f),
            Expression::Invoke(c) => write!(f, "({:?})", c),
            Expression::Field(e, i) => write!(f, "{e:?}.{}", bareword_format(i)),
            Expression::Index(e, i) => write!(f, "{e:?}[{i:?}]"),
            Expression::Range(s, e, inc) => if *inc {
                write!(f, "{s:?}..={e:?}")
            } else {
                write!(f, "{s:?}..{e:?}")
            },
            Expression::Try(e, t) => if *t {
                write!(f, "{e:?}?!")
            } else {
                write!(f, "{e:?}?")
            },
            Expression::Pipe(p) => write!(f, "{:?}", p),
        }
    }
}

impl From<Invoke> for Expression {
    fn from(i: Invoke) -> Self {
        Self::Invoke(i.into())
    }
}

impl std::fmt::Debug for Invoke {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", &self.name)?;
        for arg in &self.pos_args {
            write!(f, " {:?}", arg)?;
        }
        for (key, arg) in &self.nom_args {
            write!(f, " {}={:?}", key, arg)?;
        }
        write!(f, "")
    }
}

impl std::fmt::Debug for Pipe {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self.source)?;
        for seg in &self.stages {
            write!(f, " |")?;
            if seg.filter {write!(f, "?")?}
            write!(f, " {:?}", seg.invoke)?
        }
        write!(f, "")
    }
}

/// A small module to dump an AST as HTML...
pub mod html;