Add a test for APG4b-EX26

Author: qryxip

examples/apg4b-ex26.rs

@@ -0,0 +1,250 @@
+use itertools::Itertools as _;
+use matches::matches;
+use maplit::hashmap;
+
+use std::collections::HashMap;
+use std::io::{self, Read as _};
+use std::str::FromStr;
+
+fn main() {
+    let mut input = "".to_owned();
+    io::stdin().read_to_string(&mut input).unwrap();
+    let mut env = hashmap!();
+    for line in input.lines().skip(1) {
+        line.parse::<Stmt>().unwrap().eval(&mut env);
+    }
+}
+
+#[derive(Debug)]
+enum Stmt {
+    DeclInt(char, IntExpr),
+    PrintInt(IntExpr),
+    DeclVec(char, VecExpr),
+    PrintVec(VecExpr),
+}
+
+impl Stmt {
+    fn eval(&self, env: &mut HashMap<char, Val>) {
+        match self {
+            Self::DeclInt(name, expr) => {
+                env.insert(*name, Val::Int(expr.eval(env)));
+            }
+            Self::PrintInt(expr) => println!("{}", expr.eval(env)),
+            Self::DeclVec(name, expr) => {
+                env.insert(*name, Val::Vec(expr.eval(env)));
+            }
+            Self::PrintVec(expr) => println!("[ {} ]", expr.eval(env).iter().format(" ")),
+        }
+    }
+}
+
+impl FromStr for Stmt {
+    type Err = ();
+
+    fn from_str(input: &str) -> Result<Self, ()> {
+        use nom::bytes::complete::{tag, take_while};
+        use nom::character::complete::{alpha1, char, one_of, space0};
+        use nom::combinator::map_res;
+        use nom::multi::separated_list;
+        use nom::sequence::preceded;
+        use nom::IResult;
+
+        fn parse_decl_int(input: &str) -> IResult<&str, Stmt> {
+            let (input, _) = space0(input)?;
+            let (input, _) = tag("int")(input)?;
+            let (input, _) = space0(input)?;
+            let (input, name) = parse_var_name(input)?;
+            let (input, _) = space0(input)?;
+            let (input, _) = tag("=")(input)?;
+            let (input, _) = space0(input)?;
+            let (input, expr) = parse_int_expr(input)?;
+            let (input, _) = space0(input)?;
+            let (input, _) = char(';')(input)?;
+            Ok((input, Stmt::DeclInt(name, expr)))
+        }
+
+        fn parse_print_int(input: &str) -> IResult<&str, Stmt> {
+            let (input, _) = space0(input)?;
+            let (input, _) = tag("print_int")(input)?;
+            let (input, _) = space0(input)?;
+            let (input, expr) = parse_int_expr(input)?;
+            let (input, _) = space0(input)?;
+            let (input, _) = tag(";")(input)?;
+            Ok((input, Stmt::PrintInt(expr)))
+        }
+
+        fn parse_int_expr(input: &str) -> IResult<&str, IntExpr> {
+            let (input, mut expr) = parse_int_term(input)?;
+            let (mut input, _) = space0(input)?;
+            while let Ok((next_input, op)) =
+                preceded::<_, _, _, (), _, _>(space0, one_of("+-"))(input)
+            {
+                let (next_input, term) = preceded(space0, parse_int_term)(next_input)?;
+                input = next_input;
+                expr = match op {
+                    '+' => IntExpr::Add(Box::new(expr), Box::new(term)),
+                    '-' => IntExpr::Sub(Box::new(expr), Box::new(term)),
+                    _ => unreachable!(),
+                };
+            }
+            Ok((input, expr))
+        }
+
+        fn parse_int_term(input: &str) -> IResult<&str, IntExpr> {
+            let (input, _) = space0(input)?;
+            let parser = take_while::<_, &str, _>(|c| c.is_ascii_alphanumeric());
+            let parser = map_res(parser, |word| {
+                if let Ok(n) = word.parse() {
+                    Ok(IntExpr::Lit(n))
+                } else if word.len() == 1 && matches!(word.as_bytes()[0], b'a'..=b'z') {
+                    Ok(IntExpr::Var(word.as_bytes()[0] as char))
+                } else {
+                    Err(())
+                }
+            });
+            parser(input)
+        }
+
+        fn parse_decl_vec(input: &str) -> IResult<&str, Stmt> {
+            let (input, _) = space0(input)?;
+            let (input, _) = tag("vec")(input)?;
+            let (input, _) = space0(input)?;
+            let (input, name) = parse_var_name(input)?;
+            let (input, _) = space0(input)?;
+            let (input, _) = char('=')(input)?;
+            let (input, _) = space0(input)?;
+            let (input, val) = parse_vec_expr(input)?;
+            let (input, _) = space0(input)?;
+            let (input, _) = char(';')(input)?;
+            Ok((input, Stmt::DeclVec(name, val)))
+        }
+
+        fn parse_print_vec(input: &str) -> IResult<&str, Stmt> {
+            let (input, _) = space0(input)?;
+            let (input, _) = tag("print_vec")(input)?;
+            let (input, _) = space0(input)?;
+            let (input, val) = parse_vec_expr(input)?;
+            let (input, _) = space0(input)?;
+            let (input, _) = char(';')(input)?;
+            Ok((input, Stmt::PrintVec(val)))
+        }
+
+        fn parse_vec_expr(input: &str) -> IResult<&str, VecExpr> {
+            let (mut input, mut expr) = parse_vec_term(input)?;
+            while let Ok((next_input, op)) =
+                preceded::<_, _, _, (), _, _>(space0, one_of("+-"))(input)
+            {
+                let (next_input, term) = preceded(space0, parse_vec_term)(next_input)?;
+                input = next_input;
+                expr = match op {
+                    '+' => VecExpr::Add(Box::new(expr), Box::new(term)),
+                    '-' => VecExpr::Sub(Box::new(expr), Box::new(term)),
+                    _ => unreachable!(),
+                };
+            }
+            Ok((input, expr))
+        }
+
+        fn parse_vec_term(input: &str) -> IResult<&str, VecExpr> {
+            let (input, _) = space0(input)?;
+            if let Ok((input, word)) = alpha1::<_, ()>(input) {
+                let expr = match word.as_bytes()[0] {
+                    b'a'..=b'z' => VecExpr::Var(word.as_bytes()[0] as char),
+                    _ => unimplemented!(),
+                };
+                Ok((input, expr))
+            } else {
+                let (input, _) = preceded(char('['), space0)(input)?;
+                let (input, vec) = separated_list(
+                    preceded(preceded(space0, char(',')), space0),
+                    parse_int_expr,
+                )(input)?;
+                let (input, _) = preceded(space0, char(']'))(input)?;
+                Ok((input, VecExpr::Lit(vec)))
+            }
+        }
+
+        fn parse_var_name(input: &str) -> IResult<&str, char> {
+            map_res::<_, &str, _, _, _, _, _>(alpha1, |word| {
+                if word.len() == 1 && matches!(word.as_bytes()[0], b'a'..=b'z') {
+                    Ok(word.as_bytes()[0] as char)
+                } else {
+                    Err(())
+                }
+            })(input)
+        }
+
+        parse_decl_int(input)
+            .or_else(|_| parse_print_int(input))
+            .or_else(|_| parse_decl_vec(input))
+            .or_else(|_| parse_print_vec(input))
+            .map(|(_, stmt)| stmt)
+            .map_err(|_| ())
+    }
+}
+
+#[derive(Debug)]
+enum Val {
+    Int(i32),
+    Vec(Vec<i32>),
+}
+
+impl Val {
+    fn unwrap_int(&self) -> i32 {
+        match self {
+            Self::Int(n) => *n,
+            Self::Vec(_) => panic!(),
+        }
+    }
+
+    fn unwrap_vec(&self) -> &[i32] {
+        match self {
+            Self::Int(_) => panic!(),
+            Self::Vec(vec) => vec,
+        }
+    }
+}
+
+#[derive(Debug)]
+enum IntExpr {
+    Lit(i32),
+    Var(char),
+    Add(Box<Self>, Box<Self>),
+    Sub(Box<Self>, Box<Self>),
+}
+
+impl IntExpr {
+    fn eval(&self, env: &HashMap<char, Val>) -> i32 {
+        match self {
+            Self::Lit(n) => *n,
+            Self::Var(s) => env[s].unwrap_int(),
+            Self::Add(l, r) => l.eval(env) + r.eval(env),
+            Self::Sub(l, r) => l.eval(env) - r.eval(env),
+        }
+    }
+}
+
+#[derive(Debug)]
+enum VecExpr {
+    Lit(Vec<IntExpr>),
+    Var(char),
+    Add(Box<Self>, Box<Self>),
+    Sub(Box<Self>, Box<Self>),
+}
+
+impl VecExpr {
+    fn eval(&self, env: &HashMap<char, Val>) -> Vec<i32> {
+        match self {
+            Self::Lit(v) => v.iter().map(|x| x.eval(env)).collect(),
+            Self::Var(s) => env[s].unwrap_vec().to_owned(),
+            Self::Add(l, r) => {
+                let (l, r) = (l.eval(env), r.eval(env));
+                l.into_iter().zip_eq(r).map(|(l, r)| l + r).collect()
+            }
+            Self::Sub(l, r) => {
+                let (l, r) = (l.eval(env), r.eval(env));
+                l.into_iter().zip_eq(r).map(|(l, r)| l - r).collect()
+            }
+        }
+    }
+}

examples/tests.ron

@@ -11,6 +11,10 @@
             name: "APG4b: EX25 - 集合の操作 / 3.05",
             matching: ExactWords,
         ),
+        "apg4b-ex26": (
+            name: "APG4b: EX26 - 電卓を作ろう3 / 3.06",
+            matching: ExactWords,
+        ),
         "practice-a": (
             name: "practice contest: A - Welcome to AtCoder",
             matching: ExactWords,

examples/testsets/apg4b-ex26/in/sample_01.txt

@@ -0,0 +1,5 @@
+4
+int x = 1 + 2 ;
+print_int x + 3 ;
+vec a = [ 1 , 2 , x ] ;
+print_vec a + [ 4 , 5 , 6 ] ;

examples/testsets/apg4b-ex26/in/sample_02.txt

@@ -0,0 +1,3 @@
+2
+print_int 1 - 2 ;
+print_vec [ 1 , 2 , 3 ] - [ 3 , 2 , 1 ] ;

examples/testsets/apg4b-ex26/in/sample_03.txt

@@ -0,0 +1,2 @@
+1
+print_int 5 ;

examples/testsets/apg4b-ex26/in/sample_04.txt

@@ -0,0 +1,2 @@
+1
+print_vec [ 1 , 2 ] ;

examples/testsets/apg4b-ex26/in/sample_05.txt

@@ -0,0 +1,3 @@
+2
+int x = 1 ;
+print_int x ;

examples/testsets/apg4b-ex26/in/sample_06.txt

@@ -0,0 +1,3 @@
+2
+vec a = [ 3 , 4 ] ;
+print_vec a ;

examples/testsets/apg4b-ex26/in/sample_07.txt

@@ -0,0 +1,5 @@
+4
+int x = 1 ;
+int y = 2 ;
+int z = 3 ;
+print_int x + y + z ;

examples/testsets/apg4b-ex26/in/sample_08.txt

@@ -0,0 +1,5 @@
+4
+vec a = [ 1 , 2 , 3 ] ;
+vec b = [ 4 , 5 , 6 ] ;
+vec c = [ 7 , 8 , 9 ] ;
+print_vec a + b + c ;

examples/testsets/apg4b-ex26/in/sample_09.txt

@@ -0,0 +1,7 @@
+6
+vec a = [ 1 , 2 ] ;
+vec b = a + [ 3 , 4 ] ;
+vec c = a - [ 5 , 6 ] ;
+print_vec a ;
+print_vec b ;
+print_vec c ;

examples/testsets/apg4b-ex26/out/sample_01.txt

@@ -0,0 +1,2 @@
+6
+[ 5 7 9 ]

examples/testsets/apg4b-ex26/out/sample_02.txt

@@ -0,0 +1,2 @@
+-1
+[ -2 0 2 ]

examples/testsets/apg4b-ex26/out/sample_03.txt

@@ -0,0 +1 @@
+5

examples/testsets/apg4b-ex26/out/sample_04.txt

@@ -0,0 +1 @@
+[ 1 2 ]

examples/testsets/apg4b-ex26/out/sample_05.txt

@@ -0,0 +1 @@
+1

examples/testsets/apg4b-ex26/out/sample_06.txt

@@ -0,0 +1 @@
+[ 3 4 ]

examples/testsets/apg4b-ex26/out/sample_07.txt

@@ -0,0 +1 @@
+6

examples/testsets/apg4b-ex26/out/sample_08.txt

@@ -0,0 +1 @@
+[ 12 15 18 ]

examples/testsets/apg4b-ex26/out/sample_09.txt

@@ -0,0 +1,3 @@
+[ 1 2 ]
+[ 4 6 ]
+[ -4 -4 ]