chore: checkpoint before Python removal

vendor/pest_derive/examples/base.pest

@@ -0,0 +1,2 @@
+WHITESPACE   =  _{ " " | "\t" | NEWLINE }
+int          =  @{ (ASCII_NONZERO_DIGIT ~ ASCII_DIGIT+ | ASCII_DIGIT) }

vendor/pest_derive/examples/calc.pest

@@ -0,0 +1,13 @@
+ program      =   { SOI ~ expr ~ EOI }
+   expr       =   { prefix* ~ primary ~ postfix* ~ (infix ~ prefix* ~ primary ~ postfix* )* }
+     infix    =  _{ add | sub | mul | div | pow }
+       add    =   { "+" } // Addition
+       sub    =   { "-" } // Subtraction
+       mul    =   { "*" } // Multiplication
+       div    =   { "/" } // Division
+       pow    =   { "^" } // Exponentiation
+     prefix   =  _{ neg }
+       neg    =   { "-" } // Negation
+     postfix  =  _{ fac }
+       fac    =   { "!" } // Factorial
+     primary  =  _{ int | "(" ~ expr ~ ")" }

vendor/pest_derive/examples/calc.rs

@@ -0,0 +1,110 @@
+mod parser {
+    use pest_derive::Parser;
+
+    #[derive(Parser)]
+    #[grammar = "../examples/base.pest"]
+    #[grammar = "../examples/calc.pest"]
+    pub struct Parser;
+}
+
+use parser::Rule;
+use pest::{
+    iterators::Pairs,
+    pratt_parser::{Assoc::*, Op, PrattParser},
+    Parser,
+};
+use std::io::{stdin, stdout, Write};
+
+fn parse_to_str(pairs: Pairs<Rule>, pratt: &PrattParser<Rule>) -> String {
+    pratt
+        .map_primary(|primary| match primary.as_rule() {
+            Rule::int => primary.as_str().to_owned(),
+            Rule::expr => parse_to_str(primary.into_inner(), pratt),
+            _ => unreachable!(),
+        })
+        .map_prefix(|op, rhs| match op.as_rule() {
+            Rule::neg => format!("(-{})", rhs),
+            _ => unreachable!(),
+        })
+        .map_postfix(|lhs, op| match op.as_rule() {
+            Rule::fac => format!("({}!)", lhs),
+            _ => unreachable!(),
+        })
+        .map_infix(|lhs, op, rhs| match op.as_rule() {
+            Rule::add => format!("({}+{})", lhs, rhs),
+            Rule::sub => format!("({}-{})", lhs, rhs),
+            Rule::mul => format!("({}*{})", lhs, rhs),
+            Rule::div => format!("({}/{})", lhs, rhs),
+            Rule::pow => format!("({}^{})", lhs, rhs),
+            _ => unreachable!(),
+        })
+        .parse(pairs)
+}
+
+fn parse_to_i32(pairs: Pairs<Rule>, pratt: &PrattParser<Rule>) -> i128 {
+    pratt
+        .map_primary(|primary| match primary.as_rule() {
+            Rule::int => primary.as_str().parse().unwrap(),
+            Rule::expr => parse_to_i32(primary.into_inner(), pratt),
+            _ => unreachable!(),
+        })
+        .map_prefix(|op, rhs| match op.as_rule() {
+            Rule::neg => -rhs,
+            _ => unreachable!(),
+        })
+        .map_postfix(|lhs, op| match op.as_rule() {
+            Rule::fac => (1..lhs + 1).product(),
+            _ => unreachable!(),
+        })
+        .map_infix(|lhs, op, rhs| match op.as_rule() {
+            Rule::add => lhs + rhs,
+            Rule::sub => lhs - rhs,
+            Rule::mul => lhs * rhs,
+            Rule::div => lhs / rhs,
+            Rule::pow => (1..rhs + 1).map(|_| lhs).product(),
+            _ => unreachable!(),
+        })
+        .parse(pairs)
+}
+
+fn main() {
+    let pratt = PrattParser::new()
+        .op(Op::infix(Rule::add, Left) | Op::infix(Rule::sub, Left))
+        .op(Op::infix(Rule::mul, Left) | Op::infix(Rule::div, Left))
+        .op(Op::infix(Rule::pow, Right))
+        .op(Op::prefix(Rule::neg))
+        .op(Op::postfix(Rule::fac));
+
+    let stdin = stdin();
+    let mut stdout = stdout();
+
+    loop {
+        let source = {
+            print!("> ");
+            let _ = stdout.flush();
+            let mut input = String::new();
+            let _ = stdin.read_line(&mut input);
+            input.trim().to_string()
+        };
+
+        let pairs = match parser::Parser::parse(Rule::program, &source) {
+            Ok(mut parse_tree) => {
+                parse_tree
+                    .next()
+                    .unwrap()
+                    .into_inner() // inner of program
+                    .next()
+                    .unwrap()
+                    .into_inner() // inner of expr
+            }
+            Err(err) => {
+                println!("Failed parsing input: {:}", err);
+                continue;
+            }
+        };
+
+        print!("{} => ", source);
+        print!("{} => ", parse_to_str(pairs.clone(), &pratt));
+        println!("{}", parse_to_i32(pairs.clone(), &pratt));
+    }
+}

vendor/pest_derive/examples/help-menu.pest

@@ -0,0 +1,36 @@
+WHITESPACE = _{ " " }
+
+Rew       = ! { ( ASCII_DIGIT | ASCII_ALPHA_UPPER | "_" | "-" ) + }
+Lit       = ! { ( ASCII_ALPHANUMERIC              | "_" | "-" ) + }
+Word      = _ { Rew | Lit }
+WordGroup = _ { Word ~ ( " " ~ Word ) * }
+
+// Argument groups are nonatomic;
+// "<whitespace |between|the|bar|or|braces |is | OK>"
+
+ArgOptChoiceGroup = { ( "[" ~ Word + ~
+                      ( "|" ~ ( Word
+                              | ArgChoiceGroup ) + ) * ~
+                        "]" ) + }
+ArgReqChoiceGroup = { ( "<" ~ Word + ~
+                      ( "|" ~ ( Word
+                              | ArgChoiceGroup ) + ) * ~
+                        ">" ) + }
+ArgChoiceGroup    = _ { ArgOptChoiceGroup
+                      | ArgReqChoiceGroup }
+
+Command = {
+    ( WordGroup ) ~
+    ( ArgChoiceGroup ) *
+}
+
+HelpMenu = {
+    SOI ~
+
+    (
+        Command ~
+        NEWLINE
+    ) * ~
+
+    EOI
+}

vendor/pest_derive/examples/help-menu.rs

@@ -0,0 +1,28 @@
+#[macro_use]
+extern crate pest_derive;
+extern crate pest;
+
+use pest::Parser;
+
+#[derive(Parser)]
+#[grammar = "../examples/help-menu.pest"]
+struct HelpMenuGrammar;
+
+const INPUT: &str = r"cli help
+cli positional-command <required-single-argument> [optional-single-argument]
+cli [choice | of | one | or | none | of | these | options]
+cli <choice | of | one | of | these | options>
+cli [nesting | <is | ok>]
+";
+
+fn main() {
+    HelpMenuGrammar::parse(Rule::HelpMenu, INPUT)
+        .expect("Error parsing file")
+        .next()
+        .expect("Infallible")
+        .into_inner()
+        .filter(|pair| Rule::Command == pair.as_rule())
+        .for_each(|pair| {
+            println!("{:#?}", pair);
+        });
+}