refirio.org

The Cargo home directory is located at: C:\Users\refirio\.cargo This can be modified with the CARGO_HOME environment variable. The cargo, rustc, rustup and other commands will be added to Cargo's bin directory, located at: C:\Users\refirio\.cargo\bin This path will then be added to your PATH environment variable by modifying the HKEY_CURRENT_USER/Environment/PATH registry key. You can uninstall at any time with rustup self uninstall and these changes will be reverted. Current installation options: default host triple: x86_64-pc-windows-msvc default toolchain: stable (default) profile: default modify PATH variable: yes 1) Proceed with standard installation (default - just press enter) 2) Customize installation 3) Cancel installation >1 … 「1」と入力してEnterを入力 info: profile set to 'default' info: default host triple is x86_64-pc-windows-msvc info: syncing channel updates for 'stable-x86_64-pc-windows-msvc' info: latest update on 2024-06-13, rust version 1.79.0 (129f3b996 2024-06-10) info: downloading component 'cargo' info: downloading component 'clippy' info: downloading component 'rust-docs' info: downloading component 'rust-std' info: downloading component 'rustc' 57.7 MiB / 57.7 MiB (100 %) 25.1 MiB/s in 2s ETA: 0s info: downloading component 'rustfmt' info: installing component 'cargo' 6.4 MiB / 6.4 MiB (100 %) 5.5 MiB/s in 1s ETA: 0s info: installing component 'clippy' info: installing component 'rust-docs' 15.4 MiB / 15.4 MiB (100 %) 1.5 MiB/s in 19s ETA: 0s info: installing component 'rust-std' 18.3 MiB / 18.3 MiB (100 %) 4.8 MiB/s in 3s ETA: 0s info: installing component 'rustc' 57.7 MiB / 57.7 MiB (100 %) 4.9 MiB/s in 11s ETA: 0s info: installing component 'rustfmt' info: default toolchain set to 'stable-x86_64-pc-windows-msvc' stable-x86_64-pc-windows-msvc installed - rustc 1.79.0 (129f3b996 2024-06-10) Rust is installed now. Great! To get started you may need to restart your current shell. This would reload its PATH environment variable to include Cargo's bin directory (%USERPROFILE%\.cargo\bin). Press the Enter key to continue. … Enterを入力

fn main() { println!("Hello, world!"); }

fn main() { println!("Hello, world!"); }

fn main() { println!("Hello, world!"); /* println!("Hello, world!"); */ //println!("Hello, world!"); }

fn main() { let x = 100; //x = 200; println!("値 {} は変数xに拘束されています。", x); }

fn main() { let x = 100; println!("値 {x} は変数xに拘束されています。"); let values = vec![1, 2, 3, 4]; println!("values: {values:?}"); }

fn main() { let mut x = 100; x = 200; println!("値 {} は変数xに拘束されています。", x); }

fn main() { let x; x = 100; println!("値 {} は変数xに拘束されています。", x); }

fn main() { let x: i32 = 100; let y: f32 = 0.5; let result = (x as f32) * y; println!("計算結果は {} です。", result); }

let x = 10; // i32 let y = 3.14; // f64

fn main() { const TAX_RATE: f32 = 1.1; let price: i32 = 100; let total_price = (price as f32 * TAX_RATE) as i32; println!("100円の税込み価格は {} 円です。", total_price); }

fn main() { let t = (2, 3.14, 0); let (a, b, c) = t; println!("a={}, b={}, c={}", a, b, c); let x = t.0; let y = t.1; let z = t.2; println!("x={}, y={}, z={}", x, y, z); }

fn main() { let a = [1, 2, 3, 4, 5]; let x = a[0]; let y = a[1]; let z = a[2]; println!("x={}, y={}, z={}", x, y, z); }

fn main() { let age = 20; if age >= 25 { println!("選挙権と被選挙権があります。"); } else if age >= 18 { println!("選挙権があります。"); } else { println!("選挙権がありません。"); } }

fn main() { let age = 20; let s = if age >= 25 { "選挙権と被選挙権があります。" } else if age >= 18 { "選挙権があります。" } else { "選挙権がありません。" }; println!("{}", s); }

fn main() { let size = 'S'; match size { 'Z' => println!("{}はアルファベット最後の文字です。", size), // 単一値のマッチング 'S' | 'M' | 'L' => println!("{}はサイズを表すアルファベットです。", size), // 複数値のマッチング '0'..='9' | 'A'..='F' => println!("{}は16進数で使う文字です。", size), // 範囲を指定したマッチング _ => println!("{}はいずれでもない文字です。", size), // いずれにもマッチしなかった場合 }; }

fn main() { let size = 'S'; let explain = match size { 'Z' => "アルファベット最後の文字", // 単一値のマッチング 'S' | 'M' | 'L' => "サイズを表すアルファベット", // 複数値のマッチング '0'..='9' | 'A'..='F' => "16進数で使う文字", // 範囲を指定したマッチング _ => "いずれでもない文字", // いずれにもマッチしなかった場合 }; println!("{}は{}です。", size, explain); }

fn main() { let max = 10; let mut count = 1; let mut sum = 0; while count <= max { sum += count; count += 1; } println!("{}までの合計は{}です。", max, sum); }

fn main() { loop { // 永遠に続くのでCtrl＋Cを入力して止める println!("永遠に続くループ。"); } }

fn main() { let scores = [90, 80, 85, 70, 95]; for score in scores.iter() { println!("点数は{}点です。", score); } }

fn sample() { println!("シンプルな関数です。"); } fn main() { println!("関数を呼び出します。"); sample(); println!("関数を呼び出しました。"); }

fn sum(x: i32, y: i32) { println!("合計は{}です。", x + y); } fn main() { println!("関数を呼び出します。"); sum(3, 2); println!("関数を呼び出しました。"); }

fn sum(x: i32, y: i32) -> i32 { //return x + y; // returnで返す x + y // 最後に評価された式で返す } fn main() { println!("関数を呼び出します。"); let a = sum(3, 2); println!("合計は{}です。", a); println!("関数を呼び出しました。"); }

fn add(a: i32) -> impl Fn(i32) -> i32 { move |b| a + b } fn main() { let add_five = add(5); // add(5)が「5を足す関数」を返す let result1 = add_five(3); // add_five内で「5 + 3 = 8」が計算される println!("{}", result1); // 出力: 8 let add_seven = add(7); // add(7)が「7を足す関数」を返す let result2 = add_seven(2); // add_five内で「7 + 2 = 9」が計算される println!("{}", result2); // 出力: 9 let result3 = add(1)(5); // 直接関数を指定できる。この場合「1 + 5 = 6」が計算される println!("{}", result3); // 出力: 6 }

fn main() { let square = | x: i32 | { x * x }; println!("{}", square(9)); }

macro_rules! log { ($x:expr) => { println!("{}", $x); } } fn main() { log!("TEST"); }

fn main() { let x = 1; let y = x; println!("xは{}です。", x); // 「xは1です。」となる println!("yは{}です。", y); // 「yは1です。」となる }

fn main() { let s1 = String::from("Hello, Rust!"); //let s1 = "Hello, Rust!".to_string(); // このように書くこともできる //let s1 = "Hello, Rust!"; // このように書くこともできる let s2 = s1; println!("s1は{}です。", s1); // コンパイルエラーになるので実行されない println!("s2は{}です。", s2); }

fn main() { let s = String::from("Hello, Rust!"); let c = 'R'; let (s2, pos) = search_position(s, c); println!("文字'{}'は「{}」内の{}文字目にあります。", c, s2, pos); // ここではsを参照できない } fn search_position(s: String, c: char) -> (String, usize) { let pos = s.find(c).unwrap(); (s, pos) }

fn main() { let s = String::from("Hello, Rust!"); let c = 'R'; let pos = search_position(&s, c); // 参照（&）で値を渡し、位置だけを受け取る println!("文字'{}'は「{}」内の{}文字目にあります。", c, s, pos); } fn search_position(s: &String, c: char) -> usize { // 参照（&）で値を受け取る let pos = s.find(c).unwrap(); pos // 位置だけを返す }

fn main() { let s = String::from("Hello, Rust!"); let r = &s; println!("sは「{}」です。", s); println!("rは「{}」です。", r); // rを参照できる let s2 = s; println!("s2は「{}」です。", s2); println!("rは「{}」です。", r); // sの所有権が移動したので、rを参照できない }

fn main() { let mut s = String::from("Hello"); println!("変更前の文字列は「{}」です。", s); change_string(&mut s); println!("変更後の文字列は「{}」です。", s); } fn change_string(s: &mut String) { s.push_str(", Rust!"); }

fn main() { let opt: Option<i32> = Some(42); println!("{}", opt.unwrap()); // 「42」と表示される let opt: Option<i32> = None; println!("{}", opt.unwrap()); // panicが発生する }

fn main() { let opt: Option<i32> = Some(42); println!("{}", opt.unwrap()); // 「42」と表示される let opt: Option<i32> = None; println!("{}", opt.unwrap_or(0)); // 「0」と表示される }

struct Person { name: String, height: f64, weight: f64, } fn main() { let taro = Person { name: String::from("山田太郎"), height: 170.0, weight: 60.0, }; println!("{}さんの身長は{}、体重は{}です。", taro.name, taro.height, taro.weight); }

struct Person { name: String, height: f64, weight: f64, } impl Person { fn bmi(&self) -> f64 { self.weight / ((self.height / 100.0) * (self.height / 100.0)) } } fn main() { let taro = Person { name: String::from("山田太郎"), height: 170.0, weight: 60.0, }; println!("{}さんの身長は{}、体重は{}です。", taro.name, taro.height, taro.weight); println!("{}さんのBMIは{}です。", taro.name, taro.bmi()); }

struct Person { name: String, } impl Person { fn say_hello(&self) -> &Self { println!("{}さんこんにちは。", self.name); self } fn say_bye(&self) -> &Self { println!("{}さんさようなら。", self.name); self } } fn main() { let taro = Person { name: String::from("山田太郎"), }; taro.say_hello().say_bye(); }

enum Card { HEART, SPADE, DIAMOND, CLOVER, } fn main() { let card = Card::SPADE; match card { Card::HEART => println!("カードはハートです。"), Card::SPADE => println!("カードはスペードです。"), Card::DIAMOND => println!("カードはダイヤです。"), Card::CLOVER => println!("カードはクローバーです。"), _ => println!("カードはどれでもありません。"), } }

enum Card { HEART, SPADE, DIAMOND, CLOVER, } impl Card { // カードの名前を返すメソッド fn get_name(&self) -> &str { match self { Card::HEART => "ハート", Card::SPADE => "スペード", Card::DIAMOND => "ダイヤ", Card::CLOVER => "クローバー", } } // カードの色を返すメソッド fn get_color(&self) -> &str { match self { Card::HEART | Card::DIAMOND => "赤", Card::SPADE | Card::CLOVER => "黒", } } } fn main() { let card = Card::SPADE; println!("カードは{}です。色は{}です。", card.get_name(), card.get_color()); let another_card = Card::HEART; println!("カードは{}です。色は{}です。", another_card.get_name(), another_card.get_color()); }

trait Tweet { fn tweet(&self); fn tweet_twice(&self) { self.tweet(); self.tweet(); } fn shout(&self) { println!("Uoooohh!!!!"); } } struct Dove(); struct Duck(); impl Tweet for Dove { fn tweet(&self) { println!("Coo!"); } } impl Tweet for Duck { fn tweet(&self) { println!("Quack!"); } } fn main() { let dove = Dove {}; dove.tweet(); dove.tweet_twice(); dove.shout(); let duck = Duck {}; duck.tweet(); duck.tweet_twice(); duck.shout(); }

struct Data{ value: i32, } fn main() { let d = Data {value: 2}; println!("{:?}", d); }

enum Result<T, E> { Ok(T), // 成功 Err(E), // 失敗 }

enum Option<T> { None, // 値がない Some(T), // 値がある }

fn main() { let input1 = "+2"; let input2 = "-3"; let input3 = "42"; print_sign(input1); // "+" print_sign(input2); // "-" print_sign(input3); // "No sign found." } fn print_sign(input: &str) { if let Some(sign @ ('+' | '-')) = input.chars().next() { println!("{}", sign); } else { println!("No sign found."); } }

fn main() { let value = "10"; //let value = "ABC"; let val = if let Ok(n) = value.parse::<i32>() { println!("{} is a number.", value); // 10 is a number. println!("n = {}", n); // n = 10 } else { println!("{} is not a number.", value); }; println!("val = {:?}", val); // val = () }

#[derive(PartialEq, Debug)] enum Sample { Value1(String), Value2(String), } fn main() { let sample = Sample::Value1("Hello".to_string()); if Sample::Value1("Hello".to_string()) == sample { println!("Your state is Value1({:?})", sample); } else { println!("Your state is Value2."); }; }

enum Sample { Value1(String), Value2(String), } fn main() { let sample = Sample::Value1("Hello".to_string()); if let Sample::Value1(state_inner) = sample { println!("Your state is Value1({})", state_inner); } else { println!("Your state is Value2."); }; }

enum Sample { Value1(String), Value2(String), } fn main() { let sample = Sample::Value1("Hello".to_string()); let state_inner = if let Sample::Value1(state_inner) = sample { state_inner } else { println!("Your state is Value2."); return; }; println!("Your state is Value1({})", state_inner); }

fn main() { let value = "A B C"; let tokens = value.split_whitespace().rev().collect::<Vec<_>>(); //let tokens: Vec<_> = value.split_whitespace().rev().collect(); println!("{}", value); println!("{:?}", tokens); }

これはサンプルメッセージです。 Rustから読み書きします。

use std::env; use std::fs::File; use std::io::prelude::*; fn main() { let args: Vec<String> = env::args().collect(); let filename = &args[1]; let mut file = File::open(filename).unwrap(); let mut contents = String::new(); file.read_to_string(&mut contents).unwrap(); println!("{}", contents); }

use std::env; use std::fs::File; use std::io::prelude::*; fn main() { let args: Vec<String> = env::args().collect(); let filename = &args[1]; match File::open(filename) { Ok(mut file) => { let mut contents = String::new(); file.read_to_string(&mut contents).unwrap(); println!("{}", contents); }, Err(error) => { println!("ファイル{}が見つかりません。", filename); println!("{}", error) } }; }

use std::env; use std::fs::File; use std::io; use std::io::prelude::*; fn main() { let args: Vec<String> = env::args().collect(); let filename = &args[1]; match read_file(filename) { Ok(s) => println!("{}", s), Err(e) => println!("エラー：{}", e), }; } fn read_file(filename: &String) -> Result<String, io::Error> { let mut file = File::open(filename)?; let mut contents = String::new(); file.read_to_string(&mut contents)?; Ok(contents) }

use std::num::ParseIntError; // 文字列をi32に変換して返す fn check_number(x: &str) -> Result<i32, ParseIntError> { //let num: Result<i32, ParseIntError> = x.parse(); let num = x.parse(); match num { Ok(n) => Ok(n), Err(e) => Err(e), } } fn main() { // 正常なケース match check_number("10") { Ok(num) => println!("Ok: {}", num), Err(e) => println!("Err: {}", e), } // エラーが発生するケース match check_number("abc") { Ok(num) => println!("Ok: {}", num), Err(e) => println!("Err: {}", e), } }

fn check_number(x: &str) -> Result<i32, ParseIntError> { let num: i32 = x.parse()?; Ok(num) }

fn check_number(x: &str) -> Result<i32, ParseIntError> { x.parse() }

fn main() { // ベクター（同じデータ型の値を複数持つことができる） let mut months = Vec::new(); months.push("January"); months.push("February"); months.push("March"); months.push("April"); // 初期値のあるベクターはマクロでも定義できる //let months = vec!["January", "February", "March", "April"]; // 値の参照 println!("Count: {}, {:?}", months.len(), months); println!("{}", months[1]); // 値の走査 for month in &months { println!("{}", month); } }

use std::collections::HashMap; fn main() { // ハッシュマップ（キーと値のリスト。ほかの言語では「マップ」や「連想配列」などと呼ばれるもの） let mut months = HashMap::new(); months.insert("January", 1); months.insert("February", 2); months.insert("March", 3); months.insert("April", 4); // ベクターからハッシュマップを生成できる //let keys = vec!["January", "February", "March", "April"]; //let values = vec![1, 2, 3, 4]; //let months: HashMap<_, _> = keys.iter().zip(values.iter()).collect(); // 値の参照 println!("Count: {}, {:?}", months.len(), months); println!("{}", months["February"]); }

fn main() { let a = 123; let p = &a; println!("{}", *p); // 「123」と表示される println!("{}", p); // 「123」と表示される }

fn main() { let mut a = 123; // ミュータブルな変数を定義 let p = &mut a; // ミュータブルな参照を定義 *p = 456; // 参照先の値を変更 println!("{}", p); // 「456」が表示される }

fn main() { let s: &str = "Hello, Rust!"; //let s = "Hello, Rust!"; // このように書くこともできる println!("sは{}です。", s); }

fn main() { // 文字列（文字のコレクション） let jan = String::from("January"); let feb_utf8 = vec![0x46, 0x65, 0x62, 0x72, 0x75, 0x61, 0x72, 0x79]; let feb = String::from_utf8(feb_utf8).unwrap(); println!("{}, {}", jan, feb); }

fn main() { let byte_array = [b'h', b'e', b'l', b'l', b'o']; print(byte_array); } fn print(s: [u8]) { println!("{:?}", s); }

fn main() { let byte_array = [b'h', b'e', b'l', b'l', b'o']; print(Box::new(byte_array)); } fn print(s: Box<[u8]>) { println!("{:?}", s); }

struct Range<T> { min: T, max: T, } fn main() { let int_range = Range { min: 1, max: 10 }; let float_range = Range { min: 2.0, max: 5.5 }; // 型を明示することもできる //let int_range: Range<i32> = Range { min: 1, max: 10 }; //let float_range: Range<f32> = Range { min: 2.0, max: 5.5 }; println!("int_range.min = {}, int_range.max = {}", int_range.min, int_range.max); println!("float_range.min = {}, float_range.max = {}", float_range.min, float_range.max); }

use std::ops::Sub; struct Range<T> { min: T, max: T, } impl<T> Range<T> where T: Sub<Output = T> + Copy { fn difference(&self) -> T { self.max - self.min } } fn main() { let int_range = Range { min: 1, max: 10 }; let float_range = Range { min: 2.0, max: 5.5 }; println!("int_range.min = {}, int_range.max = {}, int_range.difference = {}", int_range.min, int_range.max, int_range.difference()); println!("float_range.min = {}, float_range.max = {}, float_range.difference = {}", float_range.min, float_range.max, float_range.difference()); }

fn main() { { let r; { let x = 5; r = &x; } println!("r: {}", r); } }

fn main() { let string1 = "ABC"; let string2 = "ABCD"; let result = longest(string1, string2); println!("The longest string is: {}", result); } fn longest(x: &str, y: &str) -> &str { if x.len() > y.len() { x } else { y } }

fn main() { let string1 = "ABC"; let string2 = "ABCD"; let result = longest(string1, string2); println!("The longest string is: {}", result); } fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y } }

fn main() { let string1 = String::from("ABC"); let string2 = String::from("ABCD"); let result = longest(string1, string2); println!("The longest string is: {}", result); } fn longest(x: String, y: String) -> String { if x.len() > y.len() { x } else { y } }

struct Person { name: &str, } fn main() { let taro = Person { name: "山田太郎", }; println!("{}さんこんにちは。", taro.name); }

struct Person<'a> { name: &'a str, } fn main() { let taro = Person { name: "山田太郎", }; println!("{}さんこんにちは。", taro.name); }

struct Person { name: String, } fn main() { let taro = Person { name: String::from("山田太郎"), }; println!("{}さんこんにちは。", taro.name); }

struct Person<'a> { name: &'a str, } impl<'a> Person<'a> { fn first_char(&self) -> Option<char> { self.name.chars().next() } } fn main() { let taro = Person { name: "山田太郎", }; println!("{}さんこんにちは。", taro.name); if let Some(first) = taro.first_char() { println!("先頭の文字は{}です。", first); } }

[package] name = "example" version = "0.1.0" edition = "2021" [dependencies]

fn main() { println!("Hello, world!"); }

# This file is automatically @generated by Cargo. # It is not intended for manual editing. version = 3 [[package]] name = "example" version = "0.1.0"

[dependencies] ↓ [dependencies] rand = "0.8.5"

use rand::prelude::*; fn main() { let mut rng = rand::thread_rng(); let x: f64 = rng.gen(); println!("x={}", x); }

pub mod module_a; mod module_b;

mod module_c; mod module_d;

use example::module_a; // モジュールは「use」で呼び出せる //use example::module_b; // 「pub」を指定していないので呼び出せない fn main() { println!("Hello, world!"); }

use crate::module_b;

pub fn add(left: usize, right: usize) -> usize { left + right } #[cfg(test)] mod tests { use super::*; #[test] fn it_works() { let result = add(2, 2); assert_eq!(result, 4); } }

use std::env; fn main() { let args: Vec<String> = env::args().collect(); println!("{:?}", args); }

[dependencies] ↓ [dependencies] clap = { version = "4.5.9", features = ["derive"] }

use clap::Parser; /// Simple program to greet a person #[derive(Parser, Debug)] #[command(version, about, long_about = None)] struct Args { /// Name of the person to greet #[arg(short, long)] name: String, /// Number of times to greet #[arg(short, long, default_value_t = 1)] count: u8, } fn main() { let args = Args::parse(); for _ in 0..args.count { println!("Hello {}!", args.name); } }

struct Args { /// Name of the person to greet #[arg(short = 'n', long = "name")] name: String, /// Number of times to greet #[arg(short = 'c', long = "count", default_value_t = 1)] count: u8, }

use clap::Parser; /// RPN Calculator #[derive(Parser, Debug)] #[command( version = "1.0.0", author = "refirio", about = "Super awesome sample RPN calculator." )] struct Args { /// Set the level of verbosity #[arg(short, long)] verbose: bool, /// Formulas written in RPN #[arg(name = "FILE")] formula_file: Option<String>, } fn main() { let args = Args::parse(); match args.formula_file { Some(file) => println!("File specified: {}", file), None => println!("No file specified."), } println!("Is verbosity specified?: {}", args.verbose); }

use clap::Parser; use std::fs::File; use std::io::{BufRead, BufReader}; /// RPN Calculator #[derive(Parser, Debug)] #[command( version = "1.0.0", author = "refirio", about = "Super awesome sample RPN calculator." )] struct Args { /// Set the level of verbosity #[arg(short, long)] verbose: bool, /// Formulas written in RPN #[arg(name = "FILE")] formula_file: Option<String>, } fn main() { let args = Args::parse(); if let Some(path) = args.formula_file { let f = File::open(path).unwrap(); let reader = BufReader::new(f); for line in reader.lines() { let line = line.unwrap(); println!("{}", line); } } else { println!("No file is specified."); } }

use clap::Parser; use std::fs::File; use std::io::{stdin, BufRead, BufReader}; /// RPN Calculator #[derive(Parser, Debug)] #[command( version = "1.0.0", author = "refirio", about = "Super awesome sample RPN calculator." )] struct Args { /// Set the level of verbosity #[arg(short, long)] verbose: bool, /// Formulas written in RPN #[arg(name = "FILE")] formula_file: Option<String>, } fn main() { let args = Args::parse(); if let Some(path) = args.formula_file { let f = File::open(path).unwrap(); let reader = BufReader::new(f); run(reader, args.verbose); } else { let stdin = stdin(); let reader = stdin.lock(); run(reader, args.verbose); } } fn run<R: BufRead>(mut reader: R, verbose: bool) { let mut line = String::new(); if reader.read_line(&mut line).unwrap() > 0 { println!("{}", line.trim_end()); } }

fn run<R: BufRead>(reader: R, verbose: bool) { for line in reader.lines() { let line = line.unwrap(); println!("{}", line); } }

use clap::Parser; use std::fs::File; use std::io::{stdin, BufRead, BufReader}; /// RPN Calculator #[derive(Parser, Debug)] #[command( version = "1.0.0", author = "refirio", about = "Super awesome sample RPN calculator." )] struct Args { /// Set the level of verbosity #[arg(short, long)] verbose: bool, /// Formulas written in RPN #[arg(name = "FILE")] formula_file: Option<String>, } struct RpnCalculator(bool); impl RpnCalculator { pub fn new(verbose: bool) -> Self { Self(verbose) } pub fn eval(&self, formula: &str) -> i32 { 0 } } fn main() { let args = Args::parse(); if let Some(path) = args.formula_file { let f = File::open(path).unwrap(); let reader = BufReader::new(f); run(reader, args.verbose); } else { let stdin = stdin(); let reader = stdin.lock(); run(reader, args.verbose); } } fn run<R: BufRead>(reader: R, verbose: bool) { let calc = RpnCalculator::new(verbose); for line in reader.lines() { let line = line.unwrap(); let answer = calc.eval(&line); println!("{}", answer); } }

use clap::Parser; use std::fs::File; use std::io::{stdin, BufRead, BufReader}; /// RPN Calculator #[derive(Parser, Debug)] #[command( version = "1.0.0", author = "refirio", about = "Super awesome sample RPN calculator." )] struct Args { /// Set the level of verbosity #[arg(short, long)] verbose: bool, /// Formulas written in RPN #[arg(name = "FILE")] formula_file: Option<String>, } struct RpnCalculator(bool); impl RpnCalculator { pub fn new(verbose: bool) -> Self { Self(verbose) } pub fn eval(&self, formula: &str) -> i32 { let mut tokens = formula.split_whitespace().rev().collect::<Vec<_>>(); self.eval_inner(&mut tokens) } pub fn eval_inner(&self, tokens: &mut Vec<&str>) -> i32 { let mut stack = Vec::new(); while let Some(token) = tokens.pop() { if let Ok(x) = token.parse::<i32>() { stack.push(x); } else { let y = stack.pop().expect("invalid syntax"); let x = stack.pop().expect("invalid syntax"); let res = match token { "+" => x + y, "-" => x - y, "*" => x * y, "/" => x / y, "%" => x % y, _ => panic!("invalid token"), }; stack.push(res); } // もし「-v」オプションが指定されていれば（無名フィールドの先頭要素に値があれば）、この時点でのトークンとスタックの状態を出力する if self.0 { println!("{:?} {:?}", tokens, stack); } } if stack.len() == 1 { stack[0] } else { panic!("invalid syntax") } } } fn main() { let args = Args::parse(); if let Some(path) = args.formula_file { let f = File::open(path).unwrap(); let reader = BufReader::new(f); run(reader, args.verbose); } else { let stdin = stdin(); let reader = stdin.lock(); run(reader, args.verbose); } } fn run<R: BufRead>(reader: R, verbose: bool) { let calc = RpnCalculator::new(verbose); for line in reader.lines() { let line = line.unwrap(); let answer = calc.eval(&line); println!("{}", answer); } }

#[cfg(test)] mod tests { use super::*; #[test] fn test_ok() { assert_eq!(2 * 2, 4); } }

#[cfg(test)] mod tests { use super::*; #[test] fn test_ok() { let calc = RpnCalculator::new(false); assert_eq!(calc.eval("5"), 5); assert_eq!(calc.eval("50"), 50); assert_eq!(calc.eval("-50"), -50); assert_eq!(calc.eval("2 3 +"), 5); assert_eq!(calc.eval("2 3 -"), -1); assert_eq!(calc.eval("2 3 *"), 6); assert_eq!(calc.eval("2 3 /"), 0); assert_eq!(calc.eval("2 3 %"), 2); } #[test] #[should_panic] fn test_ng() { let calc = RpnCalculator::new(false); assert_eq!(calc.eval("2 3 ^"), 5); } }

use std::fs; fn get_int_from_file() -> i32 { let path = "number.txt"; let num_str = fs::read_to_string(path).expect("failed to open the file."); let ret = num_str .trim() .parse::<i32>() .expect("failed to parse string to a number."); ret * 2 } fn main() { println!("{}", get_int_from_file()); }

use std::fs; fn get_int_from_file() -> Result<i32, String> { let path = "number.txt"; let num_str = fs::read_to_string(path).map_err(|e| e.to_string())?; let ret = num_str .trim() .parse::<i32>() .map(|t| t * 2) .map_err(|e| e.to_string()); ret } fn main() { match get_int_from_file() { Ok(x) => println!("{}", x), Err(e) => println!("{}", e), } }

anyhow = "1.0"

use std::fs; use anyhow::{Context, Result}; fn get_int_from_file() -> Result<i32> { let path = "number.txt"; let num_str = fs::read_to_string(path).with_context(|| format!("failed to read string from {}", path))?; let ret = num_str .trim() .parse::<i32>() .map(|t| t * 2) .context("failed to parse string"); ret } fn main() { match get_int_from_file() { Ok(x) => println!("{}", x), Err(e) => println!("{}", e), } }

use clap::Parser; use std::path::PathBuf; use std::fs::File; use std::io::{stdin, BufRead, BufReader}; use anyhow::{bail, ensure, Context, Result}; /// RPN Calculator #[derive(Parser, Debug)] #[command( version = "1.0.0", author = "refirio", about = "Super awesome sample RPN calculator." )] struct Args { /// Set the level of verbosity #[arg(short, long)] verbose: bool, /// Formulas written in RPN #[arg(name = "FILE")] formula_file: Option<PathBuf>, } struct RpnCalculator(bool); impl RpnCalculator { pub fn new(verbose: bool) -> Self { Self(verbose) } pub fn eval(&self, formula: &str) -> Result<i32> { let mut tokens = formula.split_whitespace().rev().collect::<Vec<_>>(); self.eval_inner(&mut tokens) } pub fn eval_inner(&self, tokens: &mut Vec<&str>) -> Result<i32> { let mut stack = Vec::new(); let mut pos = 0; while let Some(token) = tokens.pop() { pos += 1; if let Ok(x) = token.parse::<i32>() { stack.push(x); } else { let y = stack.pop().context(format!("invalid syntax at {}", pos))?; let x = stack.pop().context(format!("invalid syntax at {}", pos))?; let res = match token { "+" => x + y, "-" => x - y, "*" => x * y, "/" => x / y, "%" => x % y, _ => bail!("invalid token at {}", pos), }; stack.push(res); } // もし「-v」オプションが指定されていれば（無名フィールドの先頭要素に値があれば）、この時点でのトークンとスタックの状態を出力する if self.0 { println!("{:?} {:?}", tokens, stack); } } ensure!(stack.len() == 1, "invalid syntax"); Ok(stack[0]) } } fn main() -> Result<()> { let args = Args::parse(); if let Some(path) = args.formula_file { let f = File::open(path)?; let reader = BufReader::new(f); run(reader, args.verbose) } else { let stdin = stdin(); let reader = stdin.lock(); run(reader, args.verbose) } } fn run<R: BufRead>(reader: R, verbose: bool) -> Result<()> { let calc = RpnCalculator::new(verbose); for line in reader.lines() { let line = line?; match calc.eval(&line) { Ok(answer) => println!("{}", answer), Err(e) => eprintln!("{:#?}", e), } } Ok(()) } #[cfg(test)] mod tests { use super::*; #[test] fn test_ok() { let calc = RpnCalculator::new(false); assert_eq!(calc.eval("5").unwrap(), 5); assert_eq!(calc.eval("50").unwrap(), 50); assert_eq!(calc.eval("-50").unwrap(), -50); assert_eq!(calc.eval("2 3 +").unwrap(), 5); assert_eq!(calc.eval("2 3 -").unwrap(), -1); assert_eq!(calc.eval("2 3 *").unwrap(), 6); assert_eq!(calc.eval("2 3 /").unwrap(), 0); assert_eq!(calc.eval("2 3 %").unwrap(), 2); } #[test] #[should_panic] fn test_ng() { let calc = RpnCalculator::new(false); assert_eq!(calc.eval("2 3 ^").unwrap(), 5); } }

[dependencies] ↓ [dependencies] actix-web = "4.8" actix-rt = "2.10"

use actix_web::{get, App, HttpServer, Responder}; #[get("/")] async fn index() -> impl Responder { format!("Hello, world!") } #[actix_web::main] async fn main() -> std::io::Result<()> { HttpServer::new(|| { App::new().service(index) }) .bind(("127.0.0.1", 8080))? .run() .await }

use actix_web::{get, web, App, HttpServer, Responder}; #[get("/")] async fn index() -> impl Responder { format!("Hello, world!") } #[get("/hello/{name}")] async fn hello(name: web::Path<String>) -> impl Responder { format!("Hello, {name}!") } #[actix_web::main] async fn main() -> std::io::Result<()> { HttpServer::new(|| { App::new() .service(index) .service(hello) }) .bind(("127.0.0.1", 8080))? .run() .await }

fn main() { let mut stack = vec![]; stack.push(42); stack.push(36); add(&mut stack); println!("stack: {stack:?}"); } fn add(stack: &mut Vec<i32>) { let x = stack.pop().unwrap(); let y = stack.pop().unwrap(); stack.push(x + y); }

fn main() { let mut stack = vec![]; stack.push(42); stack.push(36); add(&mut stack); println!("stack: {stack:?}"); } fn add(stack: &mut Vec<i32>) { let x = stack.pop().unwrap(); let y = stack.pop().unwrap(); stack.push(x + y); }

fn main() { for line in std::io::stdin().lines() { let mut stack = vec![]; if let Ok(line) = line { let words: Vec<_> = line.split(" ").collect(); for word in words { if let Ok(parsed) = word.parse::<i32>() { stack.push(parsed); } else { match word { "+" => add(&mut stack), _ => panic!("{word:?} could not be parsed"), } } } println!("stack: {stack:?}"); } } } fn add(stack: &mut Vec<i32>) { let x = stack.pop().unwrap(); let y = stack.pop().unwrap(); stack.push(x + y); }

fn main() { for line in std::io::stdin().lines() { let mut stack = vec![]; if let Ok(line) = line { let words: Vec<_> = line.split(" ").collect(); for word in words { if let Ok(parsed) = word.parse::<i32>() { stack.push(parsed); } else { match word { "+" => add(&mut stack), "-" => sub(&mut stack), "*" => mul(&mut stack), "/" => div(&mut stack), "%" => rem(&mut stack), _ => panic!("{word:?} could not be parsed"), } } } println!("stack: {stack:?}"); } } } fn add(stack: &mut Vec<i32>) { let y = stack.pop().unwrap(); let x = stack.pop().unwrap(); stack.push(x + y); } fn sub(stack: &mut Vec<i32>) { let y = stack.pop().unwrap(); let x = stack.pop().unwrap(); stack.push(x - y); } fn mul(stack: &mut Vec<i32>) { let y = stack.pop().unwrap(); let x = stack.pop().unwrap(); stack.push(x * y); } fn div(stack: &mut Vec<i32>) { let y = stack.pop().unwrap(); let x = stack.pop().unwrap(); stack.push(x / y); } fn rem(stack: &mut Vec<i32>) { let y = stack.pop().unwrap(); let x = stack.pop().unwrap(); stack.push(x % y); }

#[derive(Debug, PartialEq, Eq)] enum Value<'src> { Num(i32), Op(&'src str), Block(Vec<Value<'src>>), } impl<'src> Value<'src> { fn as_num(&self) -> i32 { match self { Self::Num(val) => *val, _=> panic!("Value is not a number"), } } } fn main() { for line in std::io::stdin().lines().flatten() { parse(&line); } } fn parse<'a>(line: &'a str) -> Vec<Value> { let mut stack = vec![]; let input: Vec<_> = line.split(" ").collect(); let mut words = &input[..]; while let Some((&word, mut rest)) = words.split_first() { if word.is_empty() { break; } if word == "{" { let value; (value, rest) = parse_block(rest); stack.push(value); } else if let Ok(parsed) = word.parse::<i32>() { stack.push(Value::Num(parsed)); } else { match word { "+" => add(&mut stack), "-" => sub(&mut stack), "*" => mul(&mut stack), "/" => div(&mut stack), "%" => rem(&mut stack), _ => panic!("{word:?} could not be parsed"), } } words = rest; } println!("stack: {stack:?}"); stack } fn parse_block<'src, 'a>(input: &'a[&'src str]) -> (Value<'src>, &'a[&'src str]) { let mut tokens = vec![]; let mut words = input; while let Some((&word, mut rest)) = words.split_first() { if word.is_empty() { break; } if word == "{" { let value; (value, rest) = parse_block(rest); tokens.push(value); } else if word == "}" { return(Value::Block(tokens), rest); } else if let Ok(value) = word.parse::<i32>() { tokens.push(Value::Num(value)); } else { tokens.push(Value::Op(word)); } words = rest; } (Value::Block(tokens), words) } fn add(stack: &mut Vec<Value>) { let y = stack.pop().unwrap().as_num(); let x = stack.pop().unwrap().as_num(); stack.push(Value::Num(x + y)); } fn sub(stack: &mut Vec<Value>) { let y = stack.pop().unwrap().as_num(); let x = stack.pop().unwrap().as_num(); stack.push(Value::Num(x - y)); } fn mul(stack: &mut Vec<Value>) { let y = stack.pop().unwrap().as_num(); let x = stack.pop().unwrap().as_num(); stack.push(Value::Num(x * y)); } fn div(stack: &mut Vec<Value>) { let y = stack.pop().unwrap().as_num(); let x = stack.pop().unwrap().as_num(); stack.push(Value::Num(x / y)); } fn rem(stack: &mut Vec<Value>) { let y = stack.pop().unwrap().as_num(); let x = stack.pop().unwrap().as_num(); stack.push(Value::Num(x % y)); } #[cfg(test)] mod tests { use super::{parse, Value::*}; #[test] fn test_group() { assert_eq!( parse("1 2 + { 3 4 }"), vec![Num(3), Block(vec![Num(3), Num(4)])] ); } }

#[derive(Debug, Clone, PartialEq, Eq)] enum Value<'src> { Num(i32), Op(&'src str), Block(Vec<Value<'src>>), } impl<'src> Value<'src> { fn as_num(&self) -> i32 { match self { Self::Num(val) => *val, _=> panic!("Value is not a number"), } } fn to_block(self) -> Vec<Value<'src>> { match self { Self::Block(val) => val, _=> panic!("Value is not a block"), } } } fn main() { for line in std::io::stdin().lines().flatten() { parse(&line); } } fn parse<'a>(line: &'a str) -> Vec<Value> { let mut stack = vec![]; let input: Vec<_> = line.split(" ").collect(); let mut words = &input[..]; while let Some((&word, mut rest)) = words.split_first() { if word.is_empty() { break; } if word == "{" { let value; (value, rest) = parse_block(rest); stack.push(value); } else { let code = if let Ok(num) = word.parse::<i32>() { Value::Num(num) } else { Value::Op(word) }; eval(code, &mut stack); } words = rest; } println!("stack: {stack:?}"); stack } fn eval<'src>(code: Value<'src>, stack: &mut Vec<Value<'src>>) { match code { Value::Op(op) => match op { "+" => add(stack), "-" => sub(stack), "*" => mul(stack), "/" => div(stack), "%" => rem(stack), "if" => op_if(stack), _ => panic!("{op:?} could not be parsed"), }, _ => stack.push(code.clone()), } } fn parse_block<'src, 'a>(input: &'a[&'src str]) -> (Value<'src>, &'a[&'src str]) { let mut tokens = vec![]; let mut words = input; while let Some((&word, mut rest)) = words.split_first() { if word.is_empty() { break; } if word == "{" { let value; (value, rest) = parse_block(rest); tokens.push(value); } else if word == "}" { return(Value::Block(tokens), rest); } else if let Ok(value) = word.parse::<i32>() { tokens.push(Value::Num(value)); } else { tokens.push(Value::Op(word)); } words = rest; } (Value::Block(tokens), words) } fn add(stack: &mut Vec<Value>) { let y = stack.pop().unwrap().as_num(); let x = stack.pop().unwrap().as_num(); stack.push(Value::Num(x + y)); } fn sub(stack: &mut Vec<Value>) { let y = stack.pop().unwrap().as_num(); let x = stack.pop().unwrap().as_num(); stack.push(Value::Num(x - y)); } fn mul(stack: &mut Vec<Value>) { let y = stack.pop().unwrap().as_num(); let x = stack.pop().unwrap().as_num(); stack.push(Value::Num(x * y)); } fn div(stack: &mut Vec<Value>) { let y = stack.pop().unwrap().as_num(); let x = stack.pop().unwrap().as_num(); stack.push(Value::Num(x / y)); } fn rem(stack: &mut Vec<Value>) { let y = stack.pop().unwrap().as_num(); let x = stack.pop().unwrap().as_num(); stack.push(Value::Num(x % y)); } fn op_if(stack: &mut Vec<Value>) { let false_branch = stack.pop().unwrap().to_block(); let true_branch = stack.pop().unwrap().to_block(); let cond = stack.pop().unwrap().to_block(); for code in cond { eval(code, stack); } let cond_result = stack.pop().unwrap().as_num(); if cond_result != 0 { for code in true_branch { eval(code, stack); } } else { for code in false_branch { eval(code, stack); } } } #[cfg(test)] mod tests { use super::{parse, Value::*}; #[test] fn test_group() { assert_eq!( parse("1 2 + { 3 4 }"), vec![Num(3), Block(vec![Num(3), Num(4)])] ); } #[test] fn test_if_false() { assert_eq!( parse("{ 1 -1 + } { 100 } { -100 } if"), vec![Num(-100)] ); } #[test] fn test_if_true() { assert_eq!( parse("{ 1 1 + } { 100 } { -100 } if"), vec![Num(100)] ); } }

use std::collections::HashMap; #[derive(Debug, Clone, PartialEq, Eq)] enum Value<'src> { Num(i32), Op(&'src str), Sym(&'src str), Block(Vec<Value<'src>>), } impl<'src> Value<'src> { fn as_num(&self) -> i32 { match self { Self::Num(val) => *val, _=> panic!("Value is not a number"), } } fn to_block(self) -> Vec<Value<'src>> { match self { Self::Block(val) => val, _=> panic!("Value is not a block"), } } fn as_sym(&self) -> &'src str { if let Self::Sym(sym) = self { *sym } else { panic!("Value is not a symbol") } } } struct Vm<'src> { stack: Vec<Value<'src>>, vars: HashMap<&'src str, Value<'src>>, } impl<'src> Vm<'src> { fn new() -> Self { Self { stack: vec![], vars: HashMap::new(), } } } fn main() { for line in std::io::stdin().lines().flatten() { parse(&line); } } fn parse<'a>(line: &'a str) -> Vec<Value> { let mut vm = Vm::new(); let input: Vec<_> = line.split(" ").collect(); let mut words = &input[..]; while let Some((&word, mut rest)) = words.split_first() { if word.is_empty() { break; } if word == "{" { let value; (value, rest) = parse_block(rest); vm.stack.push(value); } else { let code = if let Ok(num) = word.parse::<i32>() { Value::Num(num) } else if word.starts_with("/") { Value::Sym(&word[1..]) } else { Value::Op(word) }; eval(code, &mut vm); } words = rest; } println!("stack: {:?}", vm.stack); vm.stack } fn eval<'src>(code: Value<'src>, vm: &mut Vm<'src>) { match code { Value::Op(op) => match op { "+" => add(&mut vm.stack), "-" => sub(&mut vm.stack), "*" => mul(&mut vm.stack), "/" => div(&mut vm.stack), "%" => rem(&mut vm.stack), "<" => lt(&mut vm.stack), ">" => gt(&mut vm.stack), "if" => op_if(vm), "def" => op_def(vm), _ => { let val = vm.vars.get(op).expect(&format!( "{op:?} is not a defined operation" )); vm.stack.push(val.clone()); } }, _ => vm.stack.push(code.clone()), } } fn parse_block<'src, 'a>(input: &'a[&'src str]) -> (Value<'src>, &'a[&'src str]) { let mut tokens = vec![]; let mut words = input; while let Some((&word, mut rest)) = words.split_first() { if word.is_empty() { break; } if word == "{" { let value; (value, rest) = parse_block(rest); tokens.push(value); } else if word == "}" { return(Value::Block(tokens), rest); } else if let Ok(value) = word.parse::<i32>() { tokens.push(Value::Num(value)); } else { tokens.push(Value::Op(word)); } words = rest; } (Value::Block(tokens), words) } macro_rules! impl_op { {$name:ident, $op:tt} => { fn $name(stack: &mut Vec<Value>) { let y = stack.pop().unwrap().as_num(); let x = stack.pop().unwrap().as_num(); stack.push(Value::Num((x $op y) as i32)); } } } impl_op!(add, +); impl_op!(sub, -); impl_op!(mul, *); impl_op!(div, /); impl_op!(rem, %); impl_op!(lt, <); impl_op!(gt, >); fn op_if(vm: &mut Vm) { let false_branch = vm.stack.pop().unwrap().to_block(); let true_branch = vm.stack.pop().unwrap().to_block(); let cond = vm.stack.pop().unwrap().to_block(); for code in cond { eval(code, vm); } let cond_result = vm.stack.pop().unwrap().as_num(); if cond_result != 0 { for code in true_branch { eval(code, vm); } } else { for code in false_branch { eval(code, vm); } } } fn op_def(vm: &mut Vm) { let value = vm.stack.pop().unwrap(); eval(value, vm); let value = vm.stack.pop().unwrap(); let sym = vm.stack.pop().unwrap().as_sym(); vm.vars.insert(sym, value); } #[cfg(test)] mod tests { use super::{parse, Value::*}; #[test] fn test_group() { assert_eq!( parse("1 2 + { 3 4 }"), vec![Num(3), Block(vec![Num(3), Num(4)])] ); } #[test] fn test_if_false() { assert_eq!( parse("{ 1 -1 + } { 100 } { -100 } if"), vec![Num(-100)] ); } #[test] fn test_if_true() { assert_eq!( parse("{ 1 1 + } { 100 } { -100 } if"), vec![Num(100)] ); } #[test] fn test_var() { assert_eq!( parse("/x 10 def /y 20 def x y *"), vec![Num(200)] ); } #[test] fn test_var_if() { assert_eq!( parse("/x 10 def /y 20 def { x y < } { x } { y } if"), vec![Num(10)] ); } }

use std::{ collections::HashMap, io::{BufRead, BufReader} }; #[derive(Debug, Clone, PartialEq, Eq)] enum Value { Num(i32), Op(String), Sym(String), Block(Vec<Value>), } impl Value { fn as_num(&self) -> i32 { match self { Self::Num(val) => *val, _=> panic!("Value is not a number"), } } fn to_string(&self) -> String { match self { Self::Num(i) => i.to_string(), Self::Op(ref s) | Self::Sym(ref s) => s.clone(), Self::Block(_) => "<Block>".to_string(), } } fn as_sym(&self) -> &str { if let Self::Sym(sym) = self { sym } else { panic!("Value is not a symbol") } } fn to_block(self) -> Vec<Value> { match self { Self::Block(val) => val, _=> panic!("Value is not a block"), } } } struct Vm { stack: Vec<Value>, vars: HashMap<String, Value>, blocks: Vec<Vec<Value>>, } impl Vm { fn new() -> Self { Self { stack: vec![], vars: HashMap::new(), blocks: vec![], } } } fn main() { if let Some(f) = std::env::args() .nth(1) .and_then(|f| std::fs::File::open(f).ok()) { parse_batch(BufReader::new(f)); } else { parse_interactive(); } } fn parse_batch(source: impl BufRead) -> Vec<Value> { let mut vm = Vm::new(); for line in source.lines().flatten() { for word in line.split(" ") { parse_word(word, &mut vm); } } vm.stack } fn parse_interactive() { let mut vm = Vm::new(); for line in std::io::stdin().lines().flatten() { for word in line.split(" ") { parse_word(word, &mut vm); } println!("stack: {:?}", vm.stack); } } fn parse_word(word: &str, vm: &mut Vm) { if word.is_empty() { return; } if word == "{" { vm.blocks.push(vec![]); } else if word == "}" { let top_block = vm.blocks.pop().expect("Block stack underrun!"); eval(Value::Block(top_block), vm); } else { let code = if let Ok(num) = word.parse::<i32>() { Value::Num(num) } else if word.starts_with("/") { Value::Sym(word[1..].to_string()) } else { Value::Op(word.to_string()) }; eval(code, vm); } } fn eval(code: Value, vm: &mut Vm) { if let Some(top_block) = vm.blocks.last_mut() { top_block.push(code); return; } match code { Value::Op(ref op) => match op as &str { "+" => add(&mut vm.stack), "-" => sub(&mut vm.stack), "*" => mul(&mut vm.stack), "/" => div(&mut vm.stack), "%" => rem(&mut vm.stack), "<" => lt(&mut vm.stack), ">" => gt(&mut vm.stack), "if" => op_if(vm), "def" => op_def(vm), "puts" => puts(vm), _ => { let val = vm.vars.get(op).expect(&format!( "{op:?} is not a defined operation" )); vm.stack.push(val.clone()); } }, _ => vm.stack.push(code.clone()), } } macro_rules! impl_op { {$name:ident, $op:tt} => { fn $name(stack: &mut Vec<Value>) { let y = stack.pop().unwrap().as_num(); let x = stack.pop().unwrap().as_num(); stack.push(Value::Num((x $op y) as i32)); } } } impl_op!(add, +); impl_op!(sub, -); impl_op!(mul, *); impl_op!(div, /); impl_op!(rem, %); impl_op!(lt, <); impl_op!(gt, >); fn op_if(vm: &mut Vm) { let false_branch = vm.stack.pop().unwrap().to_block(); let true_branch = vm.stack.pop().unwrap().to_block(); let cond = vm.stack.pop().unwrap().to_block(); for code in cond { eval(code, vm); } let cond_result = vm.stack.pop().unwrap().as_num(); if cond_result != 0 { for code in true_branch { eval(code, vm); } } else { for code in false_branch { eval(code, vm); } } } fn op_def(vm: &mut Vm) { let value = vm.stack.pop().unwrap(); eval(value, vm); let value = vm.stack.pop().unwrap(); let sym = vm.stack.pop().unwrap().as_sym().to_string(); vm.vars.insert(sym, value); } fn puts(vm: &mut Vm) { let value = vm.stack.pop().unwrap(); println!("{}", value.to_string()); } #[cfg(test)] mod tests { use super::{Value::*, *}; use std::io::Cursor; fn parse(input: &str) -> Vec<Value> { parse_batch(Cursor::new(input)) } #[test] fn test_group() { assert_eq!( parse("1 2 + { 3 4 }"), vec![Num(3), Block(vec![Num(3), Num(4)])] ); } #[test] fn test_if_false() { assert_eq!( parse("{ 1 -1 + } { 100 } { -100 } if"), vec![Num(-100)] ); } #[test] fn test_if_true() { assert_eq!( parse("{ 1 1 + } { 100 } { -100 } if"), vec![Num(100)] ); } #[test] fn test_var() { assert_eq!( parse("/x 10 def /y 20 def x y *"), vec![Num(200)] ); } #[test] fn test_var_if() { assert_eq!( parse("/x 10 def /y 20 def { x y < } { x } { y } if"), vec![Num(10)] ); } #[test] fn test_multiline() { assert_eq!( parse( r#" /x 10 def /y 20 def { x y < } { x } { y } if "# ), vec![Num(10)] ); } }

/x 10 def /y 20 def { x y < } { x } { y } if puts

use std::{ collections::HashMap, io::{BufRead, BufReader} }; #[derive(Debug, Clone, PartialEq, Eq)] enum Value { Num(i32), Op(String), Sym(String), Block(Vec<Value>), Native(NativeOp) } impl Value { fn as_num(&self) -> i32 { match self { Self::Num(val) => *val, _=> panic!("Value is not a number"), } } fn to_string(&self) -> String { match self { Self::Num(i) => i.to_string(), Self::Op(ref s) | Self::Sym(ref s) => s.clone(), Self::Block(_) => "<Block>".to_string(), Self::Native(_) => "<Native>".to_string(), } } fn as_sym(&self) -> &str { if let Self::Sym(sym) = self { sym } else { panic!("Value is not a symbol") } } fn to_block(self) -> Vec<Value> { match self { Self::Block(val) => val, _=> panic!("Value is not a block"), } } } #[derive(Clone)] struct NativeOp(fn(&mut Vm)); impl PartialEq for NativeOp { fn eq(&self, other: &NativeOp) -> bool { self.0 as *const fn() == other.0 as *const fn() } } impl Eq for NativeOp {} impl std::fmt::Debug for NativeOp { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "<NativeOp>") } } struct Vm { stack: Vec<Value>, vars: HashMap<String, Value>, blocks: Vec<Vec<Value>>, } impl Vm { fn new() -> Self { let functions: [(&str, fn(&mut Vm)); 14] = [ ("+", add), ("-", sub), ("*", mul), ("/", div), ("%", rem), ("<", lt), (">", gt), ("if", op_if), ("def", op_def), ("puts", puts), ("pop", pop), ("dup", dup), ("exch", exch), ("index", index), ]; Self { stack: vec![], vars: functions .into_iter() .map(|(name, fun)| { (name.to_owned(), Value::Native(NativeOp(fun))) }) .collect(), blocks: vec![], } } } fn main() { if let Some(f) = std::env::args() .nth(1) .and_then(|f| std::fs::File::open(f).ok()) { parse_batch(BufReader::new(f)); } else { parse_interactive(); } } fn parse_batch(source: impl BufRead) -> Vec<Value> { let mut vm = Vm::new(); for line in source.lines().flatten() { for word in line.split(" ") { parse_word(word, &mut vm); } } vm.stack } fn parse_interactive() { let mut vm = Vm::new(); for line in std::io::stdin().lines().flatten() { for word in line.split(" ") { parse_word(word, &mut vm); } println!("stack: {:?}", vm.stack); } } fn parse_word(word: &str, vm: &mut Vm) { if word.is_empty() { return; } if word == "{" { vm.blocks.push(vec![]); } else if word == "}" { let top_block = vm.blocks.pop().expect("Block stack underrun!"); eval(Value::Block(top_block), vm); } else { let code = if let Ok(num) = word.parse::<i32>() { Value::Num(num) } else if word.starts_with("/") { Value::Sym(word[1..].to_string()) } else { Value::Op(word.to_string()) }; eval(code, vm); } } fn eval(code: Value, vm: &mut Vm) { if let Some(top_block) = vm.blocks.last_mut() { top_block.push(code); return; } if let Value::Op(ref op) = code { let val = vm.vars.get(op).expect(&format!( "{op:?} is not a defined operation" )).clone(); match val { Value::Block(block) => { for code in block { eval(code, vm); } } Value::Native(op) => op.0(vm), _ => vm.stack.push(val), } } else { vm.stack.push(code.clone()); } } macro_rules! impl_op { {$name:ident, $op:tt} => { fn $name(vm: &mut Vm) { let y = vm.stack.pop().unwrap().as_num(); let x = vm.stack.pop().unwrap().as_num(); vm.stack.push(Value::Num((x $op y) as i32)); } } } impl_op!(add, +); impl_op!(sub, -); impl_op!(mul, *); impl_op!(div, /); impl_op!(rem, %); impl_op!(lt, <); impl_op!(gt, >); fn op_if(vm: &mut Vm) { let false_branch = vm.stack.pop().unwrap().to_block(); let true_branch = vm.stack.pop().unwrap().to_block(); let cond = vm.stack.pop().unwrap().to_block(); for code in cond { eval(code, vm); } let cond_result = vm.stack.pop().unwrap().as_num(); if cond_result != 0 { for code in true_branch { eval(code, vm); } } else { for code in false_branch { eval(code, vm); } } } fn op_def(vm: &mut Vm) { let value = vm.stack.pop().unwrap(); eval(value, vm); let value = vm.stack.pop().unwrap(); let sym = vm.stack.pop().unwrap().as_sym().to_string(); vm.vars.insert(sym, value); } fn puts(vm: &mut Vm) { let value = vm.stack.pop().unwrap(); println!("{}", value.to_string()); } fn pop(vm: &mut Vm) { vm.stack.pop().unwrap(); } fn dup(vm: &mut Vm) { let value = vm.stack.last().unwrap(); vm.stack.push(value.clone()); } fn exch(vm: &mut Vm) { let last = vm.stack.pop().unwrap(); let second = vm.stack.pop().unwrap(); vm.stack.push(last); vm.stack.push(second); } fn index(vm: &mut Vm) { let index = vm.stack.pop().unwrap().as_num() as usize; let value = vm.stack[vm.stack.len() - index - 1].clone(); vm.stack.push(value); } #[cfg(test)] mod tests { use super::{Value::*, *}; use std::io::Cursor; fn parse(input: &str) -> Vec<Value> { parse_batch(Cursor::new(input)) } #[test] fn test_group() { assert_eq!( parse("1 2 + { 3 4 }"), vec![Num(3), Block(vec![Num(3), Num(4)])] ); } #[test] fn test_if_false() { assert_eq!( parse("{ 1 -1 + } { 100 } { -100 } if"), vec![Num(-100)] ); } #[test] fn test_if_true() { assert_eq!( parse("{ 1 1 + } { 100 } { -100 } if"), vec![Num(100)] ); } #[test] fn test_var() { assert_eq!( parse("/x 10 def /y 20 def x y *"), vec![Num(200)] ); } #[test] fn test_var_if() { assert_eq!( parse("/x 10 def /y 20 def { x y < } { x } { y } if"), vec![Num(10)] ); } #[test] fn test_multiline() { assert_eq!( parse( r#" /x 10 def /y 20 def { x y < } { x } { y } if "# ), vec![Num(10)] ); } #[test] fn test_function() { assert_eq!( parse( r#" /double { 2 * } def 10 double "# ), vec![Num(20)] ); } }

/double { 2 * } def /square { dup * } def 10 double puts 10 square puts

/factorial { 1 factorial_int } def /factorial_int { /acc exch def /n exch def { n 2 < } { acc } { n 1 - acc n * factorial_int } if } def 10 factorial puts

fn main() { let source = "123 world"; println!( "source: {}, parsed: {:?}", source, ident(whitespace(number(source))) ); } // スペースを認識する（文字列の先頭にあるスペースを取り除く） fn whitespace(mut input: &str) -> &str { while matches!( input.chars().next(), // 先頭の文字を取得（charsでイテレータを取得し、nextで最初の文字が参照される） Some(' ') // 先頭の文字がスペースかどうか ) { let mut chars = input.chars(); // 文字列のイテレータを取得 chars.next(); // 最初の文字を取得（この時点で、先頭のスペースが消費される） input = chars.as_str(); // 残りの文字列を再割り当て（この時点で、inputから先頭のスペースが取り除かれる） } input } fn ident(mut input: &str) -> &str { if matches!( input.chars().next(), Some(_x @ ('a'..='z' | 'A'..='Z')) // 先頭の文字がアルファベットかどうか ) { while matches!( input.chars().next(), Some(_x @ ('a'..='z' | 'A'..='Z' | '0'..='9')) // 2文字目がアルファベットもしくは数字かどうか ) { let mut chars = input.chars(); chars.next(); input = chars.as_str(); } } input } fn number(mut input: &str) -> &str { if matches!( input.chars().next(), Some(_x @ ('-' | '+' | '.' | '0'..='9')) // 先頭の文字が数字かどうか（プラスマイナスの記号も含む） ) { while matches!( input.chars().next(), Some(_x @ ('.' | '0'..='9')) // 2文字目が数字かどうか（プラスマイナスの記号は含まない） ) { let mut chars = input.chars(); chars.next(); input = chars.as_str(); } } input } #[cfg(test)] mod tests { use super::*; #[test] fn test_whitespace() { assert_eq!(whitespace(" "), ""); } #[test] fn test_ident() { assert_eq!(ident("Adam"), ""); } #[test] fn test_number() { assert_eq!(number("123.45 "), " "); } }

fn main() { let input = "123 world"; println!("source: {}, parsed: {:?}", input, source(input)); let input = "Hello World"; println!("source: {}, parsed: {:?}", input, source(input)); let input = " world"; println!("source: {}, parsed: {:?}", input, source(input)); } fn source(mut input: &str) -> Vec<Token> { let mut tokens = vec![]; while !input.is_empty() { input = if let (next_input, Some(token)) = token(input) { tokens.push(token); next_input } else { break; } } tokens } #[derive(Debug, PartialEq, Eq)] enum Token { Ident, Number, } fn token(i: &str) -> (&str, Option<Token>) { if let (i, Some(ident_res)) = ident(whitespace(i)) { return (i, Some(ident_res)); } if let (i, Some(number_res)) = number(whitespace(i)) { return (i, Some(number_res)) } (i, None) } // スペースを認識する（文字列の先頭にあるスペースを取り除く） fn whitespace(mut input: &str) -> &str { while matches!( input.chars().next(), // 先頭の文字を取得（charsでイテレータを取得し、nextで最初の文字が参照される） Some(' ') // 先頭の文字がスペースかどうか ) { let mut chars = input.chars(); // 文字列のイテレータを取得 chars.next(); // 最初の文字を取得（この時点で、先頭のスペースが消費される） input = chars.as_str(); // 残りの文字列を再割り当て（この時点で、inputから先頭のスペースが取り除かれる） } input } // アルファベットを認識する（文字列の先頭にあるアルファベットを取り除く） fn ident(mut input: &str) -> (&str, Option<Token>) { if matches!( input.chars().next(), Some(_x @ ('a'..='z' | 'A'..='Z')) // 先頭の文字がアルファベットかどうか ) { while matches!( input.chars().next(), Some(_x @ ('a'..='z' | 'A'..='Z' | '0'..='9')) // 2文字目がアルファベットもしくは数字かどうか ) { let mut chars = input.chars(); chars.next(); input = chars.as_str(); } (input, Some(Token::Ident)) } else { (input, None) } } // 数字を認識する（文字列の先頭にある数字を取り除く） fn number(mut input: &str) -> (&str, Option<Token>) { if matches!( input.chars().next(), Some(_x @ ('-' | '+' | '.' | '0'..='9')) // 先頭の文字が数字かどうか（プラスマイナスの記号も含む） ) { while matches!( input.chars().next(), Some(_x @ ('.' | '0'..='9')) // 2文字目が数字かどうか（プラスマイナスの記号は含まない） ) { let mut chars = input.chars(); chars.next(); input = chars.as_str(); } (input, Some(Token::Number)) } else { (input, None) } } #[cfg(test)] mod tests { use super::*; #[test] fn test_whitespace() { assert_eq!(whitespace(" "), ""); } #[test] fn test_ident() { assert_eq!(ident("Adam"), ("", Some(Token::Ident))); } #[test] fn test_number() { assert_eq!(number("123.45 "), (" ", Some(Token::Number))); } }

fn main() { let input = "(123 456 world)"; println!("source: {}, parsed: {:?}", input, source(input)); let input = "((car cdr) cdr)"; println!("source: {}, parsed: {:?}", input, source(input)); let input = "()())))((()))"; println!("source: {}, parsed: {:?}", input, source(input)); } fn advance_char(input: &str) -> &str { let mut chars = input.chars(); chars.next(); chars.as_str() } fn peek_char(input: &str) -> Option<char> { input.chars().next() } fn source(mut input: &str) -> Vec<Token> { let mut tokens = vec![]; while !input.is_empty() { input = if let (next_input, Some(token)) = token(input) { tokens.push(token); next_input } else { break; } } tokens } #[derive(Debug, PartialEq, Eq)] enum Token { Ident, Number, LParen, RParen, } fn token(i: &str) -> (&str, Option<Token>) { if let (i, Some(ident_res)) = ident(whitespace(i)) { return (i, Some(ident_res)); } if let (i, Some(number_res)) = number(whitespace(i)) { return (i, Some(number_res)) } if let (i, Some(number_res)) = lparen(whitespace(i)) { return (i, Some(number_res)) } if let (i, Some(number_res)) = rparen(whitespace(i)) { return (i, Some(number_res)) } (whitespace(i), None) } // スペースを認識する（文字列の先頭にあるスペースを取り除く） fn whitespace(mut input: &str) -> &str { while matches!( peek_char(input), Some(' ') // 先頭の文字がスペースかどうか ) { input = advance_char(input); } input } // アルファベットを認識する（文字列の先頭にあるアルファベットを取り除く） fn ident(mut input: &str) -> (&str, Option<Token>) { if matches!( peek_char(input), Some(_x @ ('a'..='z' | 'A'..='Z')) // 先頭の文字がアルファベットかどうか ) { while matches!( peek_char(input), Some(_x @ ('a'..='z' | 'A'..='Z' | '0'..='9')) // 2文字目がアルファベットもしくは数字かどうか ) { input = advance_char(input); } (input, Some(Token::Ident)) } else { (input, None) } } // 数字を認識する（文字列の先頭にある数字を取り除く） fn number(mut input: &str) -> (&str, Option<Token>) { if matches!( peek_char(input), Some(_x @ ('-' | '+' | '.' | '0'..='9')) // 先頭の文字が数字かどうか（プラスマイナスの記号も含む） ) { while matches!( peek_char(input), Some(_x @ ('.' | '0'..='9')) // 2文字目が数字かどうか（プラスマイナスの記号は含まない） ) { input = advance_char(input); } (input, Some(Token::Number)) } else { (input, None) } } // 左カッコを認識する（文字列の先頭にある左カッコを取り除く） fn lparen(mut input: &str) -> (&str, Option<Token>) { if matches!( peek_char(input), Some('(') // 先頭の文字が左カッコかどうか ) { input = advance_char(input); (input, Some(Token::LParen)) } else { (input, None) } } // 右カッコを認識する（文字列の先頭にある右カッコを取り除く） fn rparen(mut input: &str) -> (&str, Option<Token>) { if matches!( peek_char(input), Some(')') // 先頭の文字が右カッコかどうか ) { input = advance_char(input); (input, Some(Token::RParen)) } else { (input, None) } } #[cfg(test)] mod tests { use super::*; #[test] fn test_whitespace() { assert_eq!(whitespace(" "), ""); } #[test] fn test_ident() { assert_eq!(ident("Adam"), ("", Some(Token::Ident))); } #[test] fn test_number() { assert_eq!(number("123.45 "), (" ", Some(Token::Number))); } }

fn main() { let input = "Hello world"; println!("source: {}, parsed: {:?}", input, source(input)); let input = "(123 456 ) world"; println!("source: {}, parsed: {:?}", input, source(input)); let input = "((car cdr) cdr)"; println!("source: {}, parsed: {:?}", input, source(input)); let input = "()())))((()))"; println!("source: {}, parsed: {:?}", input, source(input)); } fn advance_char(input: &str) -> &str { let mut chars = input.chars(); chars.next(); chars.as_str() } fn peek_char(input: &str) -> Option<char> { input.chars().next() } fn source(mut input: &str) -> (&str, TokenTree) { let mut tokens = vec![]; while !input.is_empty() { input = if let Some((next_input, token)) = token(input) { match token { Token::LParen => { let (next_input, tt) = source(next_input); tokens.push(tt); next_input } Token::RParen => { return (next_input, TokenTree::Tree(tokens)) } _ => { tokens.push(TokenTree::Token(token)); next_input } } } else { break; } } (input, TokenTree::Tree(tokens)) } #[derive(Debug, PartialEq)] enum Token<'src> { Ident(&'src str), Number(f64), LParen, RParen, } #[derive(Debug, PartialEq)] enum TokenTree<'src> { Token(Token<'src>), Tree(Vec<TokenTree<'src>>), } fn token(input: &str) -> Option<(&str, Token)> { if let Some(res) = ident(whitespace(input)) { return Some(res); } if let Some(res) = number(whitespace(input)) { return Some(res); } if let Some(res) = lparen(whitespace(input)) { return Some(res); } if let Some(res) = rparen(whitespace(input)) { return Some(res); } None } // スペースを認識する（文字列の先頭にあるスペースを取り除く） fn whitespace(mut input: &str) -> &str { while matches!( peek_char(input), Some(' ') // 先頭の文字がスペースかどうか ) { input = advance_char(input); } input } // アルファベットを認識する（文字列の先頭にあるアルファベットを取り除く） fn ident(mut input: &str) -> Option<(&str, Token)> { let start = input; if matches!( peek_char(input), Some(_x @ ('a'..='z' | 'A'..='Z')) // 先頭の文字がアルファベットかどうか ) { while matches!( peek_char(input), Some(_x @ ('a'..='z' | 'A'..='Z' | '0'..='9')) // 2文字目がアルファベットもしくは数字かどうか ) { input = advance_char(input); } Some(( input, Token::Ident(&start[..(start.len() - input.len())]), )) } else { None } } // 数字を認識する（文字列の先頭にある数字を取り除く） fn number(mut input: &str) -> Option<(&str, Token)> { let start = input; if matches!( peek_char(input), Some(_x @ ('-' | '+' | '.' | '0'..='9')) // 先頭の文字が数字かどうか（プラスマイナスの記号も含む） ) { while matches!( peek_char(input), Some(_x @ ('.' | '0'..='9')) // 2文字目が数字かどうか（プラスマイナスの記号は含まない） ) { input = advance_char(input); } if let Ok(num) = start[..(start.len() - input.len())].parse::<f64>() { Some((input, Token::Number(num))) } else { None } } else { None } } // 左カッコを認識する（文字列の先頭にある左カッコを取り除く） fn lparen(mut input: &str) -> Option<(&str, Token)> { if matches!( peek_char(input), Some('(') // 先頭の文字が左カッコかどうか ) { input = advance_char(input); Some((input, Token::LParen)) } else { None } } // 右カッコを認識する（文字列の先頭にある右カッコを取り除く） fn rparen(mut input: &str) -> Option<(&str, Token)> { if matches!( peek_char(input), Some(')') // 先頭の文字が右カッコかどうか ) { input = advance_char(input); Some((input, Token::RParen)) } else { None } } #[cfg(test)] mod tests { use super::*; #[test] fn test_whitespace() { assert_eq!(whitespace(" "), ""); } #[test] fn test_ident() { assert_eq!(ident("Adam"), Some(("", Token::Ident("Adam")))); } #[test] fn test_number() { assert_eq!(number("123.45 "), Some((" ", Token::Number(123.45)))); } }

fn main() { let input = "123"; println!("source: {}, parsed: {:?}", input, expr(input)); let input = "Hello + world"; println!("source: {}, parsed: {:?}", input, expr(input)); let input = "(123 + 456 ) + world"; println!("source: {}, parsed: {:?}", input, expr(input)); let input = "car + cdr + cdr"; println!("source: {}, parsed: {:?}", input, expr(input)); let input = "((1 + 2) + (3 + 4)) + 5 + 6"; println!("source: {}, parsed: {:?}", input, expr(input)); } fn advance_char(input: &str) -> &str { let mut chars = input.chars(); chars.next(); chars.as_str() } fn peek_char(input: &str) -> Option<char> { input.chars().next() } #[derive(Debug, PartialEq)] enum Expression<'src> { Ident(&'src str), NumLiteral(f64), Add(Box<Expression<'src>>, Box<Expression<'src>>), } // 式の全体を処理する fn expr(input: &str) -> Option<(&str, Expression)> { if let Some(res) = add(input) { return Some(res); } if let Some(res) = term(input) { return Some(res); } None } // カッコで囲まれた式を処理する fn paren(input: &str) -> Option<(&str, Expression)> { let next_input = lparen(whitespace(input))?; let (next_input, expr) = expr(next_input)?; let next_input = rparen(whitespace(next_input))?; Some((next_input, expr)) } // 加算演算の左側を処理する fn add_term(input: &str) -> Option<(&str, Expression)> { let (next_input, lhs) = term(input)?; let next_input = plus(whitespace(next_input))?; Some((next_input, lhs)) } // 加算式を処理する fn add(mut input: &str) -> Option<(&str, Expression)> { let mut left = None; while let Some((next_input, expr)) = add_term(input) { if let Some(prev_left) = left { left = Some(Expression::Add( Box::new(prev_left), Box::new(expr), )) } else { left = Some(expr); } input = next_input } let left = left?; let (next_input, rhs) = expr(input)?; Some(( next_input, Expression::Add(Box::new(left), Box::new(rhs)), )) } // 項を処理する fn term(input: &str) -> Option<(&str, Expression)> { if let Some(res) = paren(input) { return Some(res) } if let Some(res) = token(input) { return Some(res) } None } // 文字列を処理する fn token(input: &str) -> Option<(&str, Expression)> { if let Some(res) = ident(whitespace(input)) { return Some(res); } if let Some(res) = number(whitespace(input)) { return Some(res); } None } // スペースを認識する（文字列の先頭にあるスペースを取り除く） fn whitespace(mut input: &str) -> &str { while matches!( peek_char(input), Some(' ') // 先頭の文字がスペースかどうか ) { input = advance_char(input); } input } // アルファベットを認識する（文字列の先頭にあるアルファベットを取り除く） fn ident(mut input: &str) -> Option<(&str, Expression)> { let start = input; if matches!( peek_char(input), Some(_x @ ('a'..='z' | 'A'..='Z')) // 先頭の文字がアルファベットかどうか ) { while matches!( peek_char(input), Some(_x @ ('a'..='z' | 'A'..='Z' | '0'..='9')) // 2文字目がアルファベットもしくは数字かどうか ) { input = advance_char(input); } } if start.len() == input.len() { None } else { Some(( input, Expression::Ident(&start[..(start.len() - input.len())]), )) } } // 数字を認識する（文字列の先頭にある数字を取り除く） fn number(mut input: &str) -> Option<(&str, Expression)> { let start = input; if matches!( peek_char(input), Some(_x @ ('-' | '+' | '.' | '0'..='9')) // 先頭の文字が数字かどうか（プラスマイナスの記号も含む） ) { while matches!( peek_char(input), Some(_x @ ('.' | '0'..='9')) // 2文字目が数字かどうか（プラスマイナスの記号は含まない） ) { input = advance_char(input); } if let Ok(num) = start[..(start.len() - input.len())].parse::<f64>() { Some((input, Expression::NumLiteral(num))) } else { None } } else { None } } // 左カッコを認識する（文字列の先頭にある左カッコを取り除く） fn lparen(input: &str) -> Option<&str> { if matches!( peek_char(input), Some('(') // 先頭の文字が左カッコかどうか ) { Some(advance_char(input)) } else { None } } // 右カッコを認識する（文字列の先頭にある右カッコを取り除く） fn rparen(input: &str) -> Option<&str> { if matches!( peek_char(input), Some(')') // 先頭の文字が右カッコかどうか ) { Some(advance_char(input)) } else { None } } // プラスを認識する（文字列の先頭にあるプラスを取り除く） fn plus(input: &str) -> Option<&str> { if matches!( peek_char(input), Some('+') // 先頭の文字がプラスかどうか ) { Some(advance_char(input)) } else { None } } #[cfg(test)] mod tests { use super::*; #[test] fn test_whitespace() { assert_eq!(whitespace(" "), ""); } #[test] fn test_ident() { assert_eq!(ident("Adam"), Some(("", Expression::Ident("Adam")))); } #[test] fn test_number() { assert_eq!(number("123.45 "), Some((" ", Expression::NumLiteral(123.45)))); } }

nom = "7.1.3"

use nom::{ branch::alt, bytes::complete::tag, character::complete::{ alpha1, alphanumeric1, char, multispace0, }, combinator::recognize, multi::{fold_many0, many0}, number::complete::recognize_float, sequence::{delimited, pair}, IResult, }; fn main() { let input = "123"; println!("source: {:?}, parsed: {:?}", input, expr(input)); let input = "Hello + world"; println!("source: {:?}, parsed: {:?}", input, expr(input)); let input = "(123 + 456 ) + world"; println!("source: {:?}, parsed: {:?}", input, expr(input)); let input = "car + cdr + cdr"; println!("source: {:?}, parsed: {:?}", input, expr(input)); let input = "((1 + 2) + (3 + 4)) + 5 + 6"; println!("source: {:?}, parsed: {:?}", input, expr(input)); } #[derive(Debug, PartialEq, Clone)] enum Token<'src> { Ident(&'src str), Number(f64), } #[derive(Debug, PartialEq, Clone)] enum Expression<'src> { Value(Token<'src>), Add(Box<Expression<'src>>, Box<Expression<'src>>), } fn term(i: &str) -> IResult<&str, Expression> { alt((number, ident, parens))(i) } fn ident(input: &str) -> IResult<&str, Expression> { let (r, res) = delimited(multispace0, identifier, multispace0)(input)?; Ok((r, Expression::Value(Token::Ident(res)))) } fn identifier(input: &str) -> IResult<&str, &str> { recognize(pair( alt((alpha1, tag("_"))), many0(alt((alphanumeric1, tag("_")))), ))(input) } fn number(input: &str) -> IResult<&str, Expression> { let (r, v) = delimited(multispace0, recognize_float, multispace0)(input)?; Ok(( r, Expression::Value(Token::Number(v.parse().map_err( |_| { nom::Err::Error(nom::error::Error { input, code: nom::error::ErrorKind::Digit, }) }, )?)), )) } fn parens(i: &str) -> IResult<&str, Expression> { delimited( multispace0, delimited(tag("("), expr, tag(")")), multispace0 )(i) } fn expr(i: &str) -> IResult<&str, Expression> { let (i, init) = term(i)?; fold_many0( pair(delimited(multispace0, char('+'), multispace0), term), move || init.clone(), |acc, (_op, val): (char, Expression)| { Expression::Add(Box::new(acc), Box::new(val)) }, )(i) } #[cfg(test)] mod tests { use super::*; #[test] fn test_number() { assert_eq!(expr("123"), Ok(("", Expression::Value(Token::Number(123.0))))); } #[test] fn test_ident() { assert_eq!(expr("hello"), Ok(("", Expression::Value(Token::Ident("hello"))))); } }

use nom::{ character::complete::digit1, IResult, }; fn main() { let input = "42abc"; match number(input) { Ok((remaining, parsed)) => println!("Input: {:?}, Parsed: {:?}, Remaining: {:?}", input, parsed, remaining), Err(error) => println!("Input: {:?}, Error: {:?}", input, error), } } fn number(input: &str) -> IResult<&str, &str> { let (input, value) = digit1(input)?; Ok((input, value)) }

use nom::{ character::complete::digit1, character::complete::multispace0, IResult, }; fn main() { let input = " 42 "; match number(input) { Ok((remaining, parsed)) => println!("Input: {:?}, Parsed: {:?}, Remaining: {:?}", input, parsed, remaining), Err(error) => println!("Input: {:?}, Error: {:?}", input, error), } } fn number(input: &str) -> IResult<&str, &str> { let (input, _) = multispace0(input)?; let (input, value) = digit1(input)?; let (input, _) = multispace0(input)?; Ok((input, value)) }

use nom::{ character::complete::digit1, character::complete::multispace0, sequence::delimited, IResult, }; fn main() { let input = " 42 "; match number(input) { Ok((remaining, parsed)) => println!("Input: {:?}, Parsed: {:?}, Remaining: {:?}", input, parsed, remaining), Err(error) => println!("Input: {:?}, Error: {:?}", input, error), } } fn number(input: &str) -> IResult<&str, &str> { let (remaining, value) = delimited( multispace0, digit1, multispace0 )(input)?; Ok((remaining, value)) }

use nom::{ character::complete::digit1, character::complete::multispace0, sequence::delimited, IResult, }; fn main() { let input = " 42 "; match number(input) { Ok((remaining, parsed)) => println!("Input: {:?}, Parsed: {:?}, Remaining: {:?}", input, parsed, remaining), Err(error) => println!("Input: {:?}, Error: {:?}", input, error), } } fn number(input: &str) -> IResult<&str, &str> { delimited( multispace0, digit1, multispace0 )(input) }

use nom::character::complete::alpha1; use nom::error::Error; fn main() { let result = alpha1::<&str, Error<&str>>("hello123"); println!("{:?}", result); }

use nom::character::complete::alphanumeric1; use nom::error::Error; fn main() { let result = alphanumeric1::<&str, Error<&str>>("hello123!"); println!("{:?}", result); }

use nom::character::complete::char; use nom::error::Error; fn main() { let parse_a = char::<&str, Error<&str>>('a'); let result = parse_a("abc"); println!("{:?}", result); }

use nom::character::complete::multispace0; use nom::error::Error; fn main() { let result = multispace0::<&str, Error<&str>>(" hello123"); println!("{:?}", result); }

use nom::{ bytes::complete::tag, character::complete::alphanumeric1, sequence::delimited, IResult, }; fn main() { let input = "[hello123]"; match parse_bracketed(input) { Ok((remaining, parsed)) => println!("Parsed: {:?}, Remaining: {:?}", parsed, remaining), Err(error) => println!("Error: {:?}", error), } } fn parse_bracketed(input: &str) -> IResult<&str, &str> { // 角括弧で囲まれた内容を抽出 delimited( tag("["), // 開始部分: "[" にマッチ alphanumeric1, // メイン: 英数字にマッチ tag("]") // 終了部分: "]" にマッチ )(input) }

use nom::{ character::complete::{multispace0, digit1}, sequence::delimited, IResult, }; fn main() { let input = " 123 "; match parse_number_with_spaces(input) { Ok((remaining, parsed)) => println!("Parsed: {:?}, Remaining: {:?}", parsed, remaining), Err(error) => println!("Error: {:?}", error), } } fn parse_number_with_spaces(input: &str) -> IResult<&str, &str> { delimited( multispace0, // 前の空白を無視 digit1, // 数値部分を解析 multispace0 // 後ろの空白を無視 )(input) }

// 大きい方の値を返す関数を定義 fn get_larger(a: i32, b: i32) -> i32 { if a > b { a } else { b } } fn main() { // 整数を渡して実行 let larger_int = get_larger(10, 20); println!("Larger integer: {}", larger_int); // 20 // 以下は型が異なるので実行できない //let larger_float = get_larger(1.5, 0.3); //println!("Larger float: {}", larger_float); }

// 大きい方の値を返す関数を定義 fn get_larger<T: PartialOrd>(a: T, b: T) -> T { if a > b { a } else { b } } fn main() { // 整数を渡して実行 let larger_int = get_larger(10, 20); println!("Larger integer: {}", larger_int); // 20 // 浮動小数点数を渡して実行 let larger_float = get_larger(1.5, 0.3); println!("Larger float: {}", larger_float); // 1.5 // 型推論を使わないで呼び出し時に明示的に型を指定して実行 let max_int = get_larger::<i32>(30, 50); let max_float = get_larger::<f64>(5.5, 3.2); println!("Larger integer: {}", max_int); // 20 println!("Larger float: {}", max_float); // 5.5 }

use nom::{ character::complete::{alpha1, digit1}, sequence::pair, IResult, }; fn main() { // サンプル入力 let inputs = vec![ "abc123", // 有効な文字列: アルファベットはじまりのアルファベットと数字の組み合わせ "ab12cd34", // 有効な文字列: アルファベットはじまりのアルファベットと数字の組み合わせ "456def", // 数字はじまり "xyz", // アルファベットのみ "789", // 数字のみ ]; // 各サンプル文字列に対してパーサーを実行 for input in inputs { match parse_combined(input) { Ok((remaining, parsed)) => println!("Input: {:?}, Parsed: {:?}, Remaining: {:?}", input, parsed, remaining), Err(error) => println!("Input: {:?}, Error: {:?}", input, error), } } } // `recognize` を使わず、アルファベットと数字の組み合わせをパースし、構造を返す fn parse_combined(input: &str) -> IResult<&str, (&str, &str)> { // `pair` によって、アルファベットと数字のペアを解析して返す pair( alpha1, // 最初にアルファベットがある digit1 // その後に数字が続く )(input) }

use nom::{ character::complete::{alpha1, digit1}, sequence::pair, combinator::recognize, IResult, }; fn main() { // サンプル入力 let inputs = vec![ "abc123", // 有効な文字列: アルファベットはじまりのアルファベットと数字の組み合わせ "ab12cd34", // 有効な文字列: アルファベットはじまりのアルファベットと数字の組み合わせ "456def", // 数字はじまり "xyz", // アルファベットのみ "789", // 数字のみ ]; // 各サンプル文字列に対してパーサーを実行 for input in inputs { match parse_combined(input) { Ok((remaining, parsed)) => println!("Input: {:?}, Parsed: {:?}, Remaining: {:?}", input, parsed, remaining), Err(error) => println!("Input: {:?}, Error: {:?}", input, error), } } } // アルファベットと数字の組み合わせをパースし、その元の文字列全体を返す fn parse_combined(input: &str) -> IResult<&str, &str> { // `recognize`を使って、パース成功部分の文字列全体を返す recognize( pair( alpha1, // 最初にアルファベットがある digit1 // その後に数字が続く ) )(input) }

use nom::{ bytes::complete::tag, character::complete::{alpha1, alphanumeric1}, combinator::recognize, multi::many0, sequence::pair, branch::alt, IResult, }; fn main() { // サンプル文字列をテストする let test_strings = vec![ "hello123", // 有効な識別子 "_variable", // アンダースコアで始まる有効な識別子 "123abc", // 数字で始まる無効な識別子 "a_b_c", // 有効な識別子 "var-1", // 無効な識別子（ハイフンが含まれている） "func_name", // 有効な識別子 ]; // 各テスト文字列について、identifier関数を使用して解析を行う for input in test_strings { match identifier(input) { Ok((remaining, parsed)) => println!("Input: {:?}, Parsed: {:?}, Remaining: {:?}", input, parsed, remaining), Err(error) => println!("Input: {:?}, Error: {:?}", input, error), } } } // 入力文字列を受け取り、識別子として有効な部分を解析する fn identifier(input: &str) -> IResult<&str, &str> { recognize( // 中にあるパーサーを実行し、パースした内容を返す pair( // 2つのパーサーを順に実行し、両方が成功した場合にパースした部分を組み合わせて返す alt( // いずれかのパーサーが成功するまで、順にパースを試みる ( alpha1, // 先頭から1文字以上のアルファベットを解析する tag("_") // 指定された文字列を解析する ) ), many0( // 0回以上繰り返し使用できるパーサーを実行し、その結果をベクターとして返す alt( ( alphanumeric1, // 先頭から1文字以上のアルファベットまたは数字を解析する tag("_") // 指定された文字列を解析する ) ) ), ) )(input) }

use nom::{ character::complete::multispace0, number::complete::recognize_float, sequence::delimited, IResult, }; fn main() { // サンプル文字列をテストする let test_strings = vec![ "123", // 有効な整数 "456.789", // 有効な小数 " 42.0 ", // 前後にスペースがある有効な小数 "-99", // 負の整数 "-3.14", // 負の小数 "abc", // 無効な数値 ]; // 各テスト文字列について、number関数を使用して解析を行う for input in test_strings { match number(input) { Ok((remaining, parsed)) => println!("Input: {:?}, Parsed: {:?}, Remaining: {:?}", input, parsed, remaining), Err(error) => println!("Input: {:?}, Error: {:?}", input, error), } } } // 入力文字列を受け取り、識別子として認識された浮動小数点数をf64にパースして返す fn number(input: &str) -> IResult<&str, f64> { let (remaining, value) = delimited(multispace0, recognize_float, multispace0)(input)?; let parsed_value: f64 = value.parse().map_err(|_| { nom::Err::Error(nom::error::Error { input, code: nom::error::ErrorKind::Digit, }) })?; Ok((remaining, parsed_value)) }

fn main() { //let input = "123"; let input = "abc"; match parse_number(input) { Ok(n) => println!("Parsed number: {}", n), Err(e) => println!("Error: {}", e), } } fn parse_number(input: &str) -> Result<i32, String> { match input.parse::<i32>() { Ok(n) => Ok(n), Err(_) => Err("Failed to parse the number".to_string()), } }

fn main() { //let input = "123"; let input = "abc"; match parse_number(input) { Ok(n) => println!("Parsed number: {}", n), Err(e) => println!("Error: {}", e), } } fn parse_number(input: &str) -> Result<i32, String> { //input.parse::<i32>().map_err(|_| "Failed to parse the number".to_string()) input.parse::<i32>().map_err( |_| { "Failed to parse the number".to_string() } ) }

nom::Err::Error(nom::error::Error { input: "abc", code: nom::error::ErrorKind::Digit, })

fn expr(i: &str) -> IResult<&str, Expression> { let (i, init) = term(i)?; fold_many0( pair(delimited(multispace0, char('+'), multispace0), term), move || init.clone(), |acc, (_op, val): (char, Expression)| { Expression::Add(Box::new(acc), Box::new(val)) }, )(i) }

fn main() { let s1 = String::from("hello"); let s2 = s1; // 所有権がs1からs2に移動 // println!("{}", s1); // この行はエラーになる。s1の所有権はs2に移動しているため、s1はもう使用できない println!("{}", s2); // "hello" が出力される }

fn main() { let s1 = String::from("hello"); let closure = || { println!("{}", s1); // クロージャ内で`s1`を使用 }; println!("{}", s1); // "hello" が出力される closure(); // クロージャ内で "hello" が出力される }

fn main() { let s1 = String::from("hello"); let closure = move || { println!("{}", s1); // クロージャ内で`s1`を使用 }; // println!("{}", s1); // この行はエラーになる。s1の所有権はクロージャに移動しているため closure(); // クロージャ内で "hello" が出力される }

use nom::character::complete::{digit1, multispace0}; use nom::sequence::delimited; use nom::multi::many0; use nom::IResult; fn main() { let input = "10 20 30"; let result = parse_numbers(input); println!("{:?}", result); } fn parse_numbers(input: &str) -> IResult<&str, Vec<&str>> { many0( delimited(multispace0, digit1, multispace0) )(input) }

use nom::character::complete::{digit1, multispace0}; use nom::sequence::delimited; use nom::multi::fold_many0; use nom::IResult; use std::str::FromStr; fn main() { let input = "10 20 30"; let result = parse_sum(input); println!("{:?}", result); } fn parse_sum(input: &str) -> IResult<&str, i32> { fold_many0( delimited(multispace0, digit1, multispace0), // 前後のスペースを無視して数値をパースする || { 0 // 初期値は0（fold_many0の仕様により、クロージャで渡す必要がある） }, |acc, item: &str| { // 変数「acc」に加算を行っていく。「acc」はaccumulator（累積変数）をもとにした命名で、「total」のような意味 acc + i32::from_str(item).unwrap() // 初期値の0に対して10・20・30が加算されていく }, )(input) }

CREATE TABLE users ( uuid UUID NOT NULL PRIMARY KEY ,name TEXT NOT NULL DEFAULT '' )

Table { name: "users", columns: [ TableColumn { name: "uuid", sql_type: "UUID", primary_key_flag: true, not_null_flag: true, default_value: None }, TableColumn { name: "name", sql_type: "TEXT", primary_key_flag: false, not_null_flag: true, default_value: Some("") } ] }

use nom::{ branch::alt, bytes::complete::tag, character::complete::{ alpha1, alphanumeric1, char, multispace0, }, combinator::recognize, multi::{fold_many0, many0}, number::complete::recognize_float, sequence::{delimited, pair}, IResult, }; fn main() { fn ex_eval<'src>( input: &'src str, ) -> Result<f64, nom::Err<nom::error::Error<&'src str>>> { expr(input).map(|(_, e)| eval(e)) } let input = "123"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "(123 + 456 ) + pi"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "10 + (100 + 1)"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "((1 + 2) + (3 + 4)) + 5 + 6"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); } #[derive(Debug, PartialEq, Clone)] enum Expression<'src> { Ident(&'src str), NumLiteral(f64), Add(Box<Expression<'src>>, Box<Expression<'src>>), } fn eval(expr: Expression) -> f64 { match expr { Expression::Ident("pi") => std::f64::consts::PI, Expression::Ident(id) => panic!("Unknown name {:?}", id), Expression::NumLiteral(n) => n, Expression::Add(lhs, rhs) => eval(*lhs) + eval(*rhs), } } fn term(i: &str) -> IResult<&str, Expression> { alt((number, ident, parens))(i) } fn ident(input: &str) -> IResult<&str, Expression> { let (r, res) = delimited(multispace0, identifier, multispace0)(input)?; Ok((r, Expression::Ident(res))) } fn identifier(input: &str) -> IResult<&str, &str> { recognize(pair( alt((alpha1, tag("_"))), many0(alt((alphanumeric1, tag("_")))), ))(input) } fn number(input: &str) -> IResult<&str, Expression> { let (r, v) = delimited(multispace0, recognize_float, multispace0)(input)?; Ok(( r, Expression::NumLiteral(v.parse().map_err( |_| { nom::Err::Error(nom::error::Error { input, code: nom::error::ErrorKind::Digit, }) }, )?), )) } fn parens(i: &str) -> IResult<&str, Expression> { delimited( multispace0, delimited(tag("("), expr, tag(")")), multispace0 )(i) } fn expr(i: &str) -> IResult<&str, Expression> { let (i, init) = term(i)?; fold_many0( pair(delimited(multispace0, char('+'), multispace0), term), move || init.clone(), |acc, (_op, val): (char, Expression)| { Expression::Add(Box::new(acc), Box::new(val)) }, )(i) } #[cfg(test)] mod tests { use super::*; #[test] fn test_number() { assert_eq!(expr("123"), Ok(("", Expression::NumLiteral(123.0)))); } #[test] fn test_pi_ident() { assert_eq!(expr("pi"), Ok(("", Expression::Ident("pi")))); } #[test] fn test_ident() { assert_eq!(expr("hello"), Ok(("", Expression::Ident("hello")))); } }

let input = "2 + 3"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input));

let input = "2 + 3"; println!("source: {:?}, parsed: {:?}", input, expr(input));

use nom::{ branch::alt, bytes::complete::tag, character::complete::{ alpha1, alphanumeric1, char, multispace0, }, combinator::recognize, error::ParseError, multi::{fold_many0, many0}, number::complete::recognize_float, sequence::{delimited, pair}, IResult, Parser, }; fn main() { fn ex_eval<'src>( input: &'src str, ) -> Result<f64, nom::Err<nom::error::Error<&'src str>>> { expr(input).map(|(_, e)| eval(e)) } let input = "123"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "2 + 3"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "5 - 2"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "2 * 3"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "6 / 2"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "2 * pi"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "(123 + 456 ) + pi"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "10 - (100 + 1)"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "(3 + 7) / (2 + 3)"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); } #[derive(Debug, PartialEq, Clone)] enum Expression<'src> { Ident(&'src str), NumLiteral(f64), Add(Box<Expression<'src>>, Box<Expression<'src>>), Sub(Box<Expression<'src>>, Box<Expression<'src>>), Mul(Box<Expression<'src>>, Box<Expression<'src>>), Div(Box<Expression<'src>>, Box<Expression<'src>>), } fn eval(expr: Expression) -> f64 { match expr { Expression::Ident("pi") => std::f64::consts::PI, Expression::Ident(id) => panic!("Unknown name {:?}", id), Expression::NumLiteral(n) => n, Expression::Add(lhs, rhs) => eval(*lhs) + eval(*rhs), Expression::Sub(lhs, rhs) => eval(*lhs) - eval(*rhs), Expression::Mul(lhs, rhs) => eval(*lhs) * eval(*rhs), Expression::Div(lhs, rhs) => eval(*lhs) / eval(*rhs), } } fn space_delimited<'src, O, E>( f: impl Parser<&'src str, O, E>, ) -> impl FnMut(&'src str) -> IResult<&'src str, O, E> where E: ParseError<&'src str>, { delimited(multispace0, f, multispace0) } fn factor(i: &str) -> IResult<&str, Expression> { alt((number, ident, parens))(i) } fn ident(input: &str) -> IResult<&str, Expression> { let (r, res) = space_delimited(identifier)(input)?; Ok((r, Expression::Ident(res))) } fn identifier(input: &str) -> IResult<&str, &str> { recognize(pair( alt((alpha1, tag("_"))), many0(alt((alphanumeric1, tag("_")))), ))(input) } fn number(input: &str) -> IResult<&str, Expression> { let (r, v) = space_delimited(recognize_float)(input)?; Ok(( r, Expression::NumLiteral(v.parse().map_err( |_| { nom::Err::Error(nom::error::Error { input, code: nom::error::ErrorKind::Digit, }) }, )?), )) } fn parens(i: &str) -> IResult<&str, Expression> { space_delimited( delimited(tag("("), expr, tag(")")) )(i) } fn term(i: &str) -> IResult<&str, Expression> { let (i, init) = factor(i)?; fold_many0( pair(space_delimited(alt((char('*'), char('/')))), factor), move || init.clone(), |acc, (op, val): (char, Expression)| { match op { '*' => Expression::Mul(Box::new(acc), Box::new(val)), '/' => Expression::Div(Box::new(acc), Box::new(val)), _ => panic!( "Multiplicative expression should have '*' or '/' operator" ), } }, )(i) } fn expr(i: &str) -> IResult<&str, Expression> { let (i, init) = term(i)?; fold_many0( pair(space_delimited(alt((char('+'), char('-')))), term), move || init.clone(), |acc, (op, val): (char, Expression)| match op { '+' => Expression::Add(Box::new(acc), Box::new(val)), '-' => Expression::Sub(Box::new(acc), Box::new(val)), _ => panic!( "Additive expression should have '+' or '-' operator" ), }, )(i) } #[cfg(test)] mod tests { use super::*; #[test] fn test_number() { assert_eq!(expr("123"), Ok(("", Expression::NumLiteral(123.0)))); } #[test] fn test_pi_ident() { assert_eq!(expr("pi"), Ok(("", Expression::Ident("pi")))); } #[test] fn test_ident() { assert_eq!(expr("hello"), Ok(("", Expression::Ident("hello")))); } }

use nom::{ branch::alt, bytes::complete::tag, character::complete::{ alpha1, alphanumeric1, char, multispace0, }, combinator::{opt, recognize}, error::ParseError, multi::{fold_many0, many0}, number::complete::recognize_float, sequence::{delimited, pair}, IResult, Parser, }; fn main() { fn ex_eval<'src>( input: &'src str, ) -> Result<f64, nom::Err<nom::error::Error<&'src str>>> { expr(input).map(|(_, e)| eval(e)) } let input = "123"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "2 + 3"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "5 - 2"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "2 * 3"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "6 / 2"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "2 * pi"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "(123 + 456 ) + pi"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "10 - (100 + 1)"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "(3 + 7) / (2 + 3)"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "sqrt(2) / 2"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "sin(pi / 4)"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); let input = "atan2(1, 1)"; println!("source: {:?}, parsed: {:?}", input, ex_eval(input)); } #[derive(Debug, PartialEq, Clone)] enum Expression<'src> { Ident(&'src str), NumLiteral(f64), FnInvoke(&'src str, Vec<Expression<'src>>), Add(Box<Expression<'src>>, Box<Expression<'src>>), Sub(Box<Expression<'src>>, Box<Expression<'src>>), Mul(Box<Expression<'src>>, Box<Expression<'src>>), Div(Box<Expression<'src>>, Box<Expression<'src>>), } fn unary_fn( f: fn(f64) -> f64, ) -> impl Fn(Vec<Expression>) -> f64 { move |args| { f(eval( args.into_iter().next().expect("function missing argument"), )) } } fn binary_fn( f: fn(f64, f64) -> f64, ) -> impl Fn(Vec<Expression>) -> f64 { move |args| { let mut args = args.into_iter(); let lhs = eval( args.next().expect("function missing the first argument"), ); let rhs = eval( args.next().expect("function missing the second argument"), ); f(lhs, rhs) } } fn eval(expr: Expression) -> f64 { use Expression::*; match expr { Ident("pi") => std::f64::consts::PI, Ident(id) => panic!("Unknown name {:?}", id), NumLiteral(n) => n, FnInvoke("sqrt", args) => unary_fn(f64::sqrt)(args), FnInvoke("sin", args) => unary_fn(f64::sin)(args), FnInvoke("cos", args) => unary_fn(f64::cos)(args), FnInvoke("tan", args) => unary_fn(f64::tan)(args), FnInvoke("asin", args) => unary_fn(f64::asin)(args), FnInvoke("acos", args) => unary_fn(f64::acos)(args), FnInvoke("atan", args) => unary_fn(f64::atan)(args), FnInvoke("atan2", args) => binary_fn(f64::atan2)(args), FnInvoke("pow", args) => binary_fn(f64::powf)(args), FnInvoke("exp", args) => unary_fn(f64::exp)(args), FnInvoke("log", args) => binary_fn(f64::log)(args), FnInvoke("log10", args) => unary_fn(f64::log10)(args), FnInvoke(name, _) => { panic!("Unknown function {name:?}") }, Add(lhs, rhs) => eval(*lhs) + eval(*rhs), Sub(lhs, rhs) => eval(*lhs) - eval(*rhs), Mul(lhs, rhs) => eval(*lhs) * eval(*rhs), Div(lhs, rhs) => eval(*lhs) / eval(*rhs), } } fn space_delimited<'src, O, E>( f: impl Parser<&'src str, O, E>, ) -> impl FnMut(&'src str) -> IResult<&'src str, O, E> where E: ParseError<&'src str>, { delimited(multispace0, f, multispace0) } fn factor(i: &str) -> IResult<&str, Expression> { alt((number, func_call, ident, parens))(i) } fn func_call(i: &str) -> IResult<&str, Expression> { let (r, ident) = space_delimited(identifier)(i)?; let (r, args) = space_delimited(delimited( tag("("), many0(delimited( multispace0, expr, space_delimited(opt(tag(","))), )), tag(")"), ))(r)?; Ok((r, Expression::FnInvoke(ident, args))) } fn ident(input: &str) -> IResult<&str, Expression> { let (r, res) = space_delimited(identifier)(input)?; Ok((r, Expression::Ident(res))) } fn identifier(input: &str) -> IResult<&str, &str> { recognize(pair( alt((alpha1, tag("_"))), many0(alt((alphanumeric1, tag("_")))), ))(input) } fn number(input: &str) -> IResult<&str, Expression> { let (r, v) = space_delimited(recognize_float)(input)?; Ok(( r, Expression::NumLiteral(v.parse().map_err( |_| { nom::Err::Error(nom::error::Error { input, code: nom::error::ErrorKind::Digit, }) }, )?), )) } fn parens(i: &str) -> IResult<&str, Expression> { space_delimited( delimited(tag("("), expr, tag(")")) )(i) } fn term(i: &str) -> IResult<&str, Expression> { let (i, init) = factor(i)?; fold_many0( pair(space_delimited(alt((char('*'), char('/')))), factor), move || init.clone(), |acc, (op, val): (char, Expression)| { match op { '*' => Expression::Mul(Box::new(acc), Box::new(val)), '/' => Expression::Div(Box::new(acc), Box::new(val)), _ => panic!( "Multiplicative expression should have '*' or '/' operator" ), } }, )(i) } fn expr(i: &str) -> IResult<&str, Expression> { let (i, init) = term(i)?; fold_many0( pair(space_delimited(alt((char('+'), char('-')))), term), move || init.clone(), |acc, (op, val): (char, Expression)| match op { '+' => Expression::Add(Box::new(acc), Box::new(val)), '-' => Expression::Sub(Box::new(acc), Box::new(val)), _ => panic!( "Additive expression should have '+' or '-' operator" ), }, )(i) } #[cfg(test)] mod tests { use super::*; #[test] fn test_number() { assert_eq!(expr("123"), Ok(("", Expression::NumLiteral(123.0)))); } #[test] fn test_pi_ident() { assert_eq!(expr("pi"), Ok(("", Expression::Ident("pi")))); } #[test] fn test_ident() { assert_eq!(expr("hello"), Ok(("", Expression::Ident("hello")))); } }

use std::io::Read; use nom::{ branch::alt, bytes::complete::tag, character::complete::{ alpha1, alphanumeric1, char, multispace0, }, combinator::{opt, recognize}, error::ParseError, multi::{fold_many0, many0, separated_list0}, number::complete::recognize_float, sequence::{delimited, pair}, Finish, IResult, Parser, }; fn main() { let mut buf = String::new(); if std::io::stdin().read_to_string(&mut buf).is_ok() { let parsed_statements = match statements(&buf) { Ok(parsed_statements) => parsed_statements, Err(e) => { eprintln!("Parse error: {e:?}"); return; } }; for statement in parsed_statements { println!("eval: {:?}", eval(statement)); } } } #[derive(Debug, PartialEq, Clone)] enum Expression<'src> { Ident(&'src str), NumLiteral(f64), FnInvoke(&'src str, Vec<Expression<'src>>), Add(Box<Expression<'src>>, Box<Expression<'src>>), Sub(Box<Expression<'src>>, Box<Expression<'src>>), Mul(Box<Expression<'src>>, Box<Expression<'src>>), Div(Box<Expression<'src>>, Box<Expression<'src>>), } type Statements<'a> = Vec<Expression<'a>>; fn unary_fn( f: fn(f64) -> f64, ) -> impl Fn(Vec<Expression>) -> f64 { move |args| { f(eval( args.into_iter().next().expect("function missing argument"), )) } } fn binary_fn( f: fn(f64, f64) -> f64, ) -> impl Fn(Vec<Expression>) -> f64 { move |args| { let mut args = args.into_iter(); let lhs = eval( args.next().expect("function missing the first argument"), ); let rhs = eval( args.next().expect("function missing the second argument"), ); f(lhs, rhs) } } fn eval(expr: Expression) -> f64 { use Expression::*; match expr { Ident("pi") => std::f64::consts::PI, Ident(id) => panic!("Unknown name {:?}", id), NumLiteral(n) => n, FnInvoke("sqrt", args) => unary_fn(f64::sqrt)(args), FnInvoke("sin", args) => unary_fn(f64::sin)(args), FnInvoke("cos", args) => unary_fn(f64::cos)(args), FnInvoke("tan", args) => unary_fn(f64::tan)(args), FnInvoke("asin", args) => unary_fn(f64::asin)(args), FnInvoke("acos", args) => unary_fn(f64::acos)(args), FnInvoke("atan", args) => unary_fn(f64::atan)(args), FnInvoke("atan2", args) => binary_fn(f64::atan2)(args), FnInvoke("pow", args) => binary_fn(f64::powf)(args), FnInvoke("exp", args) => unary_fn(f64::exp)(args), FnInvoke("log", args) => binary_fn(f64::log)(args), FnInvoke("log10", args) => unary_fn(f64::log10)(args), FnInvoke(name, _) => { panic!("Unknown function {name:?}") }, Add(lhs, rhs) => eval(*lhs) + eval(*rhs), Sub(lhs, rhs) => eval(*lhs) - eval(*rhs), Mul(lhs, rhs) => eval(*lhs) * eval(*rhs), Div(lhs, rhs) => eval(*lhs) / eval(*rhs), } } fn space_delimited<'src, O, E>( f: impl Parser<&'src str, O, E>, ) -> impl FnMut(&'src str) -> IResult<&'src str, O, E> where E: ParseError<&'src str>, { delimited(multispace0, f, multispace0) } fn factor(i: &str) -> IResult<&str, Expression> { alt((number, func_call, ident, parens))(i) } fn func_call(i: &str) -> IResult<&str, Expression> { let (r, ident) = space_delimited(identifier)(i)?; let (r, args) = space_delimited(delimited( tag("("), many0(delimited( multispace0, expr, space_delimited(opt(tag(","))), )), tag(")"), ))(r)?; Ok((r, Expression::FnInvoke(ident, args))) } fn ident(input: &str) -> IResult<&str, Expression> { let (r, res) = space_delimited(identifier)(input)?; Ok((r, Expression::Ident(res))) } fn identifier(input: &str) -> IResult<&str, &str> { recognize(pair( alt((alpha1, tag("_"))), many0(alt((alphanumeric1, tag("_")))), ))(input) } fn number(input: &str) -> IResult<&str, Expression> { let (r, v) = space_delimited(recognize_float)(input)?; Ok(( r, Expression::NumLiteral(v.parse().map_err( |_| { nom::Err::Error(nom::error::Error { input, code: nom::error::ErrorKind::Digit, }) }, )?), )) } fn parens(i: &str) -> IResult<&str, Expression> { space_delimited( delimited(tag("("), expr, tag(")")) )(i) } fn term(i: &str) -> IResult<&str, Expression> { let (i, init) = factor(i)?; fold_many0( pair(space_delimited(alt((char('*'), char('/')))), factor), move || init.clone(), |acc, (op, val): (char, Expression)| { match op { '*' => Expression::Mul(Box::new(acc), Box::new(val)), '/' => Expression::Div(Box::new(acc), Box::new(val)), _ => panic!( "Multiplicative expression should have '*' or '/' operator" ), } }, )(i) } fn expr(i: &str) -> IResult<&str, Expression> { let (i, init) = term(i)?; fold_many0( pair(space_delimited(alt((char('+'), char('-')))), term), move || init.clone(), |acc, (op, val): (char, Expression)| match op { '+' => Expression::Add(Box::new(acc), Box::new(val)), '-' => Expression::Sub(Box::new(acc), Box::new(val)), _ => panic!( "Additive expression should have '+' or '-' operator" ), }, )(i) } fn statements(i: &str) -> Result<Statements, nom::error::Error<&str>> { let (_, res) = separated_list0(tag(";"), expr)(i).finish()?; Ok(res) }

1; 2+3; 4*5; sin(pi/2);

use std::{ collections::HashMap, io::Read }; use nom::{ branch::alt, bytes::complete::tag, character::complete::{ alpha1, alphanumeric1, char, multispace0, multispace1, }, combinator::{opt, recognize}, error::ParseError, multi::{fold_many0, many0, separated_list0}, number::complete::recognize_float, sequence::{delimited, pair}, Finish, IResult, Parser, }; fn main() { let mut buf = String::new(); if !std::io::stdin().read_to_string(&mut buf).is_ok() { panic!("Failed to read from stdin"); } let parsed_statements = match statements(&buf) { Ok(parsed_statements) => parsed_statements, Err(e) => { eprintln!("Parse error: {e:?}"); return; } }; let mut variables = HashMap::new(); for statement in parsed_statements { match statement { Statement::Expression(expr) => { println!("eval: {:?}", eval(expr, &variables)) } Statement::VarDef(name, expr) => { let value = eval(expr, &variables); variables.insert(name, value); } } } } #[derive(Debug, PartialEq, Clone)] enum Expression<'src> { Ident(&'src str), NumLiteral(f64), FnInvoke(&'src str, Vec<Expression<'src>>), Add(Box<Expression<'src>>, Box<Expression<'src>>), Sub(Box<Expression<'src>>, Box<Expression<'src>>), Mul(Box<Expression<'src>>, Box<Expression<'src>>), Div(Box<Expression<'src>>, Box<Expression<'src>>), } #[derive(Debug, PartialEq, Clone)] enum Statement<'src> { Expression(Expression<'src>), VarDef(&'src str, Expression<'src>), } type Statements<'a> = Vec<Statement<'a>>; fn unary_fn( f: fn(f64) -> f64, ) -> impl Fn(Vec<Expression>, &HashMap<&str, f64>) -> f64 { move |args, variables| { f(eval( args.into_iter().next().expect("function missing argument"), variables, )) } } fn binary_fn( f: fn(f64, f64) -> f64, ) -> impl Fn(Vec<Expression>, &HashMap<&str, f64>) -> f64 { move |args, variables| { let mut args = args.into_iter(); let lhs = eval( args.next().expect("function missing the first argument"), variables, ); let rhs = eval( args.next().expect("function missing the second argument"), variables, ); f(lhs, rhs) } } fn eval(expr: Expression, vars: &HashMap<&str, f64>) -> f64 { use Expression::*; match expr { Ident("pi") => std::f64::consts::PI, Ident(id) => *vars.get(id).expect("Variable not found"), NumLiteral(n) => n, FnInvoke("sqrt", args) => unary_fn(f64::sqrt)(args, vars), FnInvoke("sin", args) => unary_fn(f64::sin)(args, vars), FnInvoke("cos", args) => unary_fn(f64::cos)(args, vars), FnInvoke("tan", args) => unary_fn(f64::tan)(args, vars), FnInvoke("asin", args) => unary_fn(f64::asin)(args, vars), FnInvoke("acos", args) => unary_fn(f64::acos)(args, vars), FnInvoke("atan", args) => unary_fn(f64::atan)(args, vars), FnInvoke("atan2", args) => binary_fn(f64::atan2)(args, vars), FnInvoke("pow", args) => binary_fn(f64::powf)(args, vars), FnInvoke("exp", args) => unary_fn(f64::exp)(args, vars), FnInvoke("log", args) => binary_fn(f64::log)(args, vars), FnInvoke("log10", args) => unary_fn(f64::log10)(args, vars), FnInvoke(name, _) => { panic!("Unknown function {name:?}") }, Add(lhs, rhs) => eval(*lhs, vars) + eval(*rhs, vars), Sub(lhs, rhs) => eval(*lhs, vars) - eval(*rhs, vars), Mul(lhs, rhs) => eval(*lhs, vars) * eval(*rhs, vars), Div(lhs, rhs) => eval(*lhs, vars) / eval(*rhs, vars), } } fn space_delimited<'src, O, E>( f: impl Parser<&'src str, O, E>, ) -> impl FnMut(&'src str) -> IResult<&'src str, O, E> where E: ParseError<&'src str>, { delimited(multispace0, f, multispace0) } fn factor(i: &str) -> IResult<&str, Expression> { alt((number, func_call, ident, parens))(i) } fn func_call(i: &str) -> IResult<&str, Expression> { let (r, ident) = space_delimited(identifier)(i)?; let (r, args) = space_delimited(delimited( tag("("), many0(delimited( multispace0, expr, space_delimited(opt(tag(","))), )), tag(")"), ))(r)?; Ok((r, Expression::FnInvoke(ident, args))) } fn ident(input: &str) -> IResult<&str, Expression> { let (r, res) = space_delimited(identifier)(input)?; Ok((r, Expression::Ident(res))) } fn identifier(input: &str) -> IResult<&str, &str> { recognize(pair( alt((alpha1, tag("_"))), many0(alt((alphanumeric1, tag("_")))), ))(input) } fn number(input: &str) -> IResult<&str, Expression> { let (r, v) = space_delimited(recognize_float)(input)?; Ok(( r, Expression::NumLiteral(v.parse().map_err( |_| { nom::Err::Error(nom::error::Error { input, code: nom::error::ErrorKind::Digit, }) }, )?), )) } fn parens(i: &str) -> IResult<&str, Expression> { space_delimited( delimited(tag("("), expr, tag(")")) )(i) } fn term(i: &str) -> IResult<&str, Expression> { let (i, init) = factor(i)?; fold_many0( pair(space_delimited(alt((char('*'), char('/')))), factor), move || init.clone(), |acc, (op, val): (char, Expression)| { match op { '*' => Expression::Mul(Box::new(acc), Box::new(val)), '/' => Expression::Div(Box::new(acc), Box::new(val)), _ => panic!( "Multiplicative expression should have '*' or '/' operator" ), } }, )(i) } fn expr(i: &str) -> IResult<&str, Expression> { let (i, init) = term(i)?; fold_many0( pair(space_delimited(alt((char('+'), char('-')))), term), move || init.clone(), |acc, (op, val): (char, Expression)| match op { '+' => Expression::Add(Box::new(acc), Box::new(val)), '-' => Expression::Sub(Box::new(acc), Box::new(val)), _ => panic!( "Additive expression should have '+' or '-' operator" ), }, )(i) } fn var_def(i: &str) -> IResult<&str, Statement> { let (i, _) = delimited(multispace0, tag("var"), multispace1)(i)?; let (i, name) = space_delimited(identifier)(i)?; let (i, _) = space_delimited(char('='))(i)?; let (i, expr) = space_delimited(expr)(i)?; Ok((i, Statement::VarDef(name, expr))) } fn expr_statement(i: &str) -> IResult<&str, Statement> { let (i, res) = expr(i)?; Ok((i, Statement::Expression(res))) } fn statement(i: &str) -> IResult<&str, Statement> { alt((var_def, expr_statement))(i) } fn statements(i: &str) -> Result<Statements, nom::error::Error<&str>> { let (_, res) = separated_list0(tag(";"), statement)(i).finish()?; Ok(res) }

var a = 1; a + 2;

use std::{ collections::HashMap, io::Read }; use nom::{ branch::alt, bytes::complete::tag, character::complete::{ alpha1, alphanumeric1, char, multispace0, multispace1, }, combinator::{opt, recognize}, error::ParseError, multi::{fold_many0, many0, separated_list0}, number::complete::recognize_float, sequence::{delimited, pair}, Finish, IResult, Parser, }; fn main() { let mut buf = String::new(); if !std::io::stdin().read_to_string(&mut buf).is_ok() { panic!("Failed to read from stdin"); } let parsed_statements = match statements(&buf) { Ok(parsed_statements) => parsed_statements, Err(e) => { eprintln!("Parse error: {e:?}"); return; } }; let mut variables = HashMap::new(); for statement in parsed_statements { match statement { Statement::Expression(expr) => { println!("eval: {:?}", eval(expr, &variables)) } Statement::VarDef(name, expr) => { let value = eval(expr, &variables); variables.insert(name, value); } Statement::VarAssign(name, expr) => { if !variables.contains_key(name) { panic!("Variable is not defined"); } let value = eval(expr, &variables); variables.insert(name, value); } } } } #[derive(Debug, PartialEq, Clone)] enum Expression<'src> { Ident(&'src str), NumLiteral(f64), FnInvoke(&'src str, Vec<Expression<'src>>), Add(Box<Expression<'src>>, Box<Expression<'src>>), Sub(Box<Expression<'src>>, Box<Expression<'src>>), Mul(Box<Expression<'src>>, Box<Expression<'src>>), Div(Box<Expression<'src>>, Box<Expression<'src>>), } #[derive(Debug, PartialEq, Clone)] enum Statement<'src> { Expression(Expression<'src>), VarDef(&'src str, Expression<'src>), VarAssign(&'src str, Expression<'src>), } type Statements<'a> = Vec<Statement<'a>>; fn unary_fn( f: fn(f64) -> f64, ) -> impl Fn(Vec<Expression>, &HashMap<&str, f64>) -> f64 { move |args, variables| { f(eval( args.into_iter().next().expect("function missing argument"), variables, )) } } fn binary_fn( f: fn(f64, f64) -> f64, ) -> impl Fn(Vec<Expression>, &HashMap<&str, f64>) -> f64 { move |args, variables| { let mut args = args.into_iter(); let lhs = eval( args.next().expect("function missing the first argument"), variables, ); let rhs = eval( args.next().expect("function missing the second argument"), variables, ); f(lhs, rhs) } } fn eval(expr: Expression, vars: &HashMap<&str, f64>) -> f64 { use Expression::*; match expr { Ident("pi") => std::f64::consts::PI, Ident(id) => *vars.get(id).expect("Variable not found"), NumLiteral(n) => n, FnInvoke("sqrt", args) => unary_fn(f64::sqrt)(args, vars), FnInvoke("sin", args) => unary_fn(f64::sin)(args, vars), FnInvoke("cos", args) => unary_fn(f64::cos)(args, vars), FnInvoke("tan", args) => unary_fn(f64::tan)(args, vars), FnInvoke("asin", args) => unary_fn(f64::asin)(args, vars), FnInvoke("acos", args) => unary_fn(f64::acos)(args, vars), FnInvoke("atan", args) => unary_fn(f64::atan)(args, vars), FnInvoke("atan2", args) => binary_fn(f64::atan2)(args, vars), FnInvoke("pow", args) => binary_fn(f64::powf)(args, vars), FnInvoke("exp", args) => unary_fn(f64::exp)(args, vars), FnInvoke("log", args) => binary_fn(f64::log)(args, vars), FnInvoke("log10", args) => unary_fn(f64::log10)(args, vars), FnInvoke(name, _) => { panic!("Unknown function {name:?}") }, Add(lhs, rhs) => eval(*lhs, vars) + eval(*rhs, vars), Sub(lhs, rhs) => eval(*lhs, vars) - eval(*rhs, vars), Mul(lhs, rhs) => eval(*lhs, vars) * eval(*rhs, vars), Div(lhs, rhs) => eval(*lhs, vars) / eval(*rhs, vars), } } fn space_delimited<'src, O, E>( f: impl Parser<&'src str, O, E>, ) -> impl FnMut(&'src str) -> IResult<&'src str, O, E> where E: ParseError<&'src str>, { delimited(multispace0, f, multispace0) } fn factor(i: &str) -> IResult<&str, Expression> { alt((number, func_call, ident, parens))(i) } fn func_call(i: &str) -> IResult<&str, Expression> { let (r, ident) = space_delimited(identifier)(i)?; let (r, args) = space_delimited(delimited( tag("("), many0(delimited( multispace0, expr, space_delimited(opt(tag(","))), )), tag(")"), ))(r)?; Ok((r, Expression::FnInvoke(ident, args))) } fn ident(input: &str) -> IResult<&str, Expression> { let (r, res) = space_delimited(identifier)(input)?; Ok((r, Expression::Ident(res))) } fn identifier(input: &str) -> IResult<&str, &str> { recognize(pair( alt((alpha1, tag("_"))), many0(alt((alphanumeric1, tag("_")))), ))(input) } fn number(input: &str) -> IResult<&str, Expression> { let (r, v) = space_delimited(recognize_float)(input)?; Ok(( r, Expression::NumLiteral(v.parse().map_err( |_| { nom::Err::Error(nom::error::Error { input, code: nom::error::ErrorKind::Digit, }) }, )?), )) } fn parens(i: &str) -> IResult<&str, Expression> { space_delimited( delimited(tag("("), expr, tag(")")) )(i) } fn term(i: &str) -> IResult<&str, Expression> { let (i, init) = factor(i)?; fold_many0( pair(space_delimited(alt((char('*'), char('/')))), factor), move || init.clone(), |acc, (op, val): (char, Expression)| { match op { '*' => Expression::Mul(Box::new(acc), Box::new(val)), '/' => Expression::Div(Box::new(acc), Box::new(val)), _ => panic!( "Multiplicative expression should have '*' or '/' operator" ), } }, )(i) } fn expr(i: &str) -> IResult<&str, Expression> { let (i, init) = term(i)?; fold_many0( pair(space_delimited(alt((char('+'), char('-')))), term), move || init.clone(), |acc, (op, val): (char, Expression)| match op { '+' => Expression::Add(Box::new(acc), Box::new(val)), '-' => Expression::Sub(Box::new(acc), Box::new(val)), _ => panic!( "Additive expression should have '+' or '-' operator" ), }, )(i) } fn var_def(i: &str) -> IResult<&str, Statement> { let (i, _) = delimited(multispace0, tag("var"), multispace1)(i)?; let (i, name) = space_delimited(identifier)(i)?; let (i, _) = space_delimited(char('='))(i)?; let (i, expr) = space_delimited(expr)(i)?; Ok((i, Statement::VarDef(name, expr))) } fn var_assign(i: &str) -> IResult<&str, Statement> { let (i, name) = space_delimited(identifier)(i)?; let (i, _) = space_delimited(char('='))(i)?; let (i, expr) = space_delimited(expr)(i)?; Ok((i, Statement::VarAssign(name, expr))) } fn expr_statement(i: &str) -> IResult<&str, Statement> { let (i, res) = expr(i)?; Ok((i, Statement::Expression(res))) } fn statement(i: &str) -> IResult<&str, Statement> { alt((var_def, var_assign, expr_statement))(i) } fn statements(i: &str) -> Result<Statements, nom::error::Error<&str>> { let (_, res) = separated_list0(tag(";"), statement)(i).finish()?; Ok(res) }

var a = 1; a = a + 2; a * 2;

use std::{ collections::HashMap, io::Read }; use nom::{ branch::alt, bytes::complete::tag, character::complete::{ alpha1, alphanumeric1, char, multispace0, multispace1, }, combinator::{opt, recognize}, error::ParseError, multi::{fold_many0, many0, separated_list0}, number::complete::recognize_float, sequence::{delimited, pair, preceded}, Finish, IResult, Parser, }; fn main() { let mut buf = String::new(); if !std::io::stdin().read_to_string(&mut buf).is_ok() { panic!("Failed to read from stdin"); } let parsed_statements = match statements(&buf) { Ok(parsed_statements) => parsed_statements, Err(e) => { eprintln!("Parse error: {e:?}"); return; } }; let mut variables = HashMap::new(); for statement in parsed_statements { match statement { Statement::Expression(expr) => { println!("eval: {:?}", eval(expr, &variables)) } Statement::VarDef(name, expr) => { let value = eval(expr, &variables); variables.insert(name, value); } Statement::VarAssign(name, expr) => { if !variables.contains_key(name) { panic!("Variable is not defined"); } let value = eval(expr, &variables); variables.insert(name, value); } } } } #[derive(Debug, PartialEq, Clone)] enum Expression<'src> { Ident(&'src str), NumLiteral(f64), FnInvoke(&'src str, Vec<Expression<'src>>), Add(Box<Expression<'src>>, Box<Expression<'src>>), Sub(Box<Expression<'src>>, Box<Expression<'src>>), Mul(Box<Expression<'src>>, Box<Expression<'src>>), Div(Box<Expression<'src>>, Box<Expression<'src>>), If( Box<Expression<'src>>, Box<Expression<'src>>, Option<Box<Expression<'src>>>, ), } #[derive(Debug, PartialEq, Clone)] enum Statement<'src> { Expression(Expression<'src>), VarDef(&'src str, Expression<'src>), VarAssign(&'src str, Expression<'src>), } type Statements<'a> = Vec<Statement<'a>>; fn unary_fn( f: fn(f64) -> f64, ) -> impl Fn(Vec<Expression>, &HashMap<&str, f64>) -> f64 { move |args, variables| { f(eval( args.into_iter().next().expect("function missing argument"), variables, )) } } fn binary_fn( f: fn(f64, f64) -> f64, ) -> impl Fn(Vec<Expression>, &HashMap<&str, f64>) -> f64 { move |args, variables| { let mut args = args.into_iter(); let lhs = eval( args.next().expect("function missing the first argument"), variables, ); let rhs = eval( args.next().expect("function missing the second argument"), variables, ); f(lhs, rhs) } } fn eval(expr: Expression, vars: &HashMap<&str, f64>) -> f64 { use Expression::*; match expr { Ident("pi") => std::f64::consts::PI, Ident(id) => *vars.get(id).expect("Variable not found"), NumLiteral(n) => n, FnInvoke("sqrt", args) => unary_fn(f64::sqrt)(args, vars), FnInvoke("sin", args) => unary_fn(f64::sin)(args, vars), FnInvoke("cos", args) => unary_fn(f64::cos)(args, vars), FnInvoke("tan", args) => unary_fn(f64::tan)(args, vars), FnInvoke("asin", args) => unary_fn(f64::asin)(args, vars), FnInvoke("acos", args) => unary_fn(f64::acos)(args, vars), FnInvoke("atan", args) => unary_fn(f64::atan)(args, vars), FnInvoke("atan2", args) => binary_fn(f64::atan2)(args, vars), FnInvoke("pow", args) => binary_fn(f64::powf)(args, vars), FnInvoke("exp", args) => unary_fn(f64::exp)(args, vars), FnInvoke("log", args) => binary_fn(f64::log)(args, vars), FnInvoke("log10", args) => unary_fn(f64::log10)(args, vars), FnInvoke(name, _) => { panic!("Unknown function {name:?}") }, Add(lhs, rhs) => eval(*lhs, vars) + eval(*rhs, vars), Sub(lhs, rhs) => eval(*lhs, vars) - eval(*rhs, vars), Mul(lhs, rhs) => eval(*lhs, vars) * eval(*rhs, vars), Div(lhs, rhs) => eval(*lhs, vars) / eval(*rhs, vars), If(cond, t_case, f_case) => { if eval(*cond, vars) != 0. { eval(*t_case, vars) } else if let Some(f_case) = f_case { eval(*f_case, vars) } else { 0. } } } } fn space_delimited<'src, O, E>( f: impl Parser<&'src str, O, E>, ) -> impl FnMut(&'src str) -> IResult<&'src str, O, E> where E: ParseError<&'src str>, { delimited(multispace0, f, multispace0) } fn factor(i: &str) -> IResult<&str, Expression> { alt((number, func_call, ident, parens))(i) } fn func_call(i: &str) -> IResult<&str, Expression> { let (r, ident) = space_delimited(identifier)(i)?; let (r, args) = space_delimited(delimited( tag("("), many0(delimited( multispace0, expr, space_delimited(opt(tag(","))), )), tag(")"), ))(r)?; Ok((r, Expression::FnInvoke(ident, args))) } fn ident(input: &str) -> IResult<&str, Expression> { let (r, res) = space_delimited(identifier)(input)?; Ok((r, Expression::Ident(res))) } fn identifier(input: &str) -> IResult<&str, &str> { recognize(pair( alt((alpha1, tag("_"))), many0(alt((alphanumeric1, tag("_")))), ))(input) } fn number(input: &str) -> IResult<&str, Expression> { let (r, v) = space_delimited(recognize_float)(input)?; Ok(( r, Expression::NumLiteral(v.parse().map_err( |_| { nom::Err::Error(nom::error::Error { input, code: nom::error::ErrorKind::Digit, }) }, )?), )) } fn parens(i: &str) -> IResult<&str, Expression> { space_delimited( delimited(tag("("), expr, tag(")")) )(i) } fn term(i: &str) -> IResult<&str, Expression> { let (i, init) = factor(i)?; fold_many0( pair(space_delimited(alt((char('*'), char('/')))), factor), move || init.clone(), |acc, (op, val): (char, Expression)| { match op { '*' => Expression::Mul(Box::new(acc), Box::new(val)), '/' => Expression::Div(Box::new(acc), Box::new(val)), _ => panic!( "Multiplicative expression should have '*' or '/' operator" ), } }, )(i) } fn num_expr(i: &str) -> IResult<&str, Expression> { let (i, init) = term(i)?; fold_many0( pair(space_delimited(alt((char('+'), char('-')))), term), move || init.clone(), |acc, (op, val): (char, Expression)| match op { '+' => Expression::Add(Box::new(acc), Box::new(val)), '-' => Expression::Sub(Box::new(acc), Box::new(val)), _ => panic!( "Additive expression should have '+' or '-' operator" ), }, )(i) } fn open_brace(i: &str) -> IResult<&str, ()> { let (i, _) = space_delimited(char('{'))(i)?; Ok((i, ())) } fn close_brace(i: &str) -> IResult<&str, ()> { let (i, _) = space_delimited(char('}'))(i)?; Ok((i, ())) } fn if_expr(i: &str) -> IResult<&str, Expression> { let (i, _) = space_delimited(tag("if"))(i)?; let (i, cond) = expr(i)?; let (i, t_case) = delimited(open_brace, expr, close_brace)(i)?; let (i, f_case) = opt(preceded( space_delimited(tag("else")), delimited(open_brace, expr, close_brace), ))(i)?; Ok(( i, Expression::If( Box::new(cond), Box::new(t_case), f_case.map(Box::new), ), )) } fn expr(i: &str) -> IResult<&str, Expression> { alt((if_expr, num_expr))(i) } fn var_def(i: &str) -> IResult<&str, Statement> { let (i, _) = delimited(multispace0, tag("var"), multispace1)(i)?; let (i, name) = space_delimited(identifier)(i)?; let (i, _) = space_delimited(char('='))(i)?; let (i, expr) = space_delimited(expr)(i)?; Ok((i, Statement::VarDef(name, expr))) } fn var_assign(i: &str) -> IResult<&str, Statement> { let (i, name) = space_delimited(identifier)(i)?; let (i, _) = space_delimited(char('='))(i)?; let (i, expr) = space_delimited(expr)(i)?; Ok((i, Statement::VarAssign(name, expr))) } fn expr_statement(i: &str) -> IResult<&str, Statement> { let (i, res) = expr(i)?; Ok((i, Statement::Expression(res))) } fn statement(i: &str) -> IResult<&str, Statement> { alt((var_def, var_assign, expr_statement))(i) } fn statements(i: &str) -> Result<Statements, nom::error::Error<&str>> { let (_, res) = separated_list0(tag(";"), statement)(i).finish()?; Ok(res) }

var one = 1; var a = if one { 10 } else { 20 }; a + 2;

use std::{ collections::HashMap, io::Read }; use nom::{ branch::alt, bytes::complete::tag, character::complete::{ alpha1, alphanumeric1, char, multispace0, multispace1, }, combinator::{opt, recognize}, error::ParseError, multi::{fold_many0, many0}, number::complete::recognize_float, sequence::{delimited, pair, preceded, terminated}, Finish, IResult, Parser, }; fn main() { let mut buf = String::new(); if !std::io::stdin().read_to_string(&mut buf).is_ok() { panic!("Failed to read from stdin"); } let parsed_statements = match statements_finish(&buf) { Ok(parsed_statements) => parsed_statements, Err(e) => { eprintln!("Parse error: {e:?}"); return; } }; let mut variables = HashMap::new(); eval_stmts(&parsed_statements, &mut variables); } type Variables = HashMap<String, f64>; fn eval_stmts(stmts: &[Statement], variables: &mut Variables) { for statement in stmts { match statement { Statement::Expression(expr) => { println!("eval: {:?}", eval(expr, variables)) } Statement::VarDef(name, expr) => { let value = eval(expr, variables); variables.insert(name.to_string(), value); } Statement::VarAssign(name, expr) => { if !variables.contains_key(*name) { panic!("Variable is not defined"); } let value = eval(expr, variables); variables.insert(name.to_string(), value); } Statement::For { loop_var, start, end, stmts, } => { let start = eval(start, variables) as isize; let end = eval(end, variables) as isize; for i in start..end { variables.insert(loop_var.to_string(), i as f64); eval_stmts(stmts, variables); } } } } } #[derive(Debug, PartialEq, Clone)] enum Expression<'src> { Ident(&'src str), NumLiteral(f64), FnInvoke(&'src str, Vec<Expression<'src>>), Add(Box<Expression<'src>>, Box<Expression<'src>>), Sub(Box<Expression<'src>>, Box<Expression<'src>>), Mul(Box<Expression<'src>>, Box<Expression<'src>>), Div(Box<Expression<'src>>, Box<Expression<'src>>), If( Box<Expression<'src>>, Box<Expression<'src>>, Option<Box<Expression<'src>>>, ), } #[derive(Debug, PartialEq, Clone)] enum Statement<'src> { Expression(Expression<'src>), VarDef(&'src str, Expression<'src>), VarAssign(&'src str, Expression<'src>), For { loop_var: &'src str, start: Expression<'src>, end: Expression<'src>, stmts: Statements<'src>, }, } type Statements<'a> = Vec<Statement<'a>>; fn unary_fn( f: fn(f64) -> f64, ) -> impl Fn(&[Expression], &Variables) -> f64 { move |args, variables| { f(eval( args.into_iter().next().expect("function missing argument"), variables, )) } } fn binary_fn( f: fn(f64, f64) -> f64, ) -> impl Fn(&[Expression], &Variables) -> f64 { move |args, variables| { let mut args = args.into_iter(); let lhs = eval( args.next().expect("function missing the first argument"), variables, ); let rhs = eval( args.next().expect("function missing the second argument"), variables, ); f(lhs, rhs) } } fn eval(expr: &Expression, vars: &Variables) -> f64 { use Expression::*; match expr { Ident("pi") => std::f64::consts::PI, Ident(id) => *vars.get(*id).expect("Variable not found"), NumLiteral(n) => *n, FnInvoke("sqrt", args) => unary_fn(f64::sqrt)(args, vars), FnInvoke("sin", args) => unary_fn(f64::sin)(args, vars), FnInvoke("cos", args) => unary_fn(f64::cos)(args, vars), FnInvoke("tan", args) => unary_fn(f64::tan)(args, vars), FnInvoke("asin", args) => unary_fn(f64::asin)(args, vars), FnInvoke("acos", args) => unary_fn(f64::acos)(args, vars), FnInvoke("atan", args) => unary_fn(f64::atan)(args, vars), FnInvoke("atan2", args) => binary_fn(f64::atan2)(args, vars), FnInvoke("pow", args) => binary_fn(f64::powf)(args, vars), FnInvoke("exp", args) => unary_fn(f64::exp)(args, vars), FnInvoke("log", args) => binary_fn(f64::log)(args, vars), FnInvoke("log10", args) => unary_fn(f64::log10)(args, vars), FnInvoke(name, _) => { panic!("Unknown function {name:?}") }, Add(lhs, rhs) => eval(lhs, vars) + eval(rhs, vars), Sub(lhs, rhs) => eval(lhs, vars) - eval(rhs, vars), Mul(lhs, rhs) => eval(lhs, vars) * eval(rhs, vars), Div(lhs, rhs) => eval(lhs, vars) / eval(rhs, vars), If(cond, t_case, f_case) => { if eval(cond, vars) != 0. { eval(t_case, vars) } else if let Some(f_case) = f_case { eval(f_case, vars) } else { 0. } } } } fn space_delimited<'src, O, E>( f: impl Parser<&'src str, O, E>, ) -> impl FnMut(&'src str) -> IResult<&'src str, O, E> where E: ParseError<&'src str>, { delimited(multispace0, f, multispace0) } fn factor(i: &str) -> IResult<&str, Expression> { alt((number, func_call, ident, parens))(i) } fn func_call(i: &str) -> IResult<&str, Expression> { let (r, ident) = space_delimited(identifier)(i)?; let (r, args) = space_delimited(delimited( tag("("), many0(delimited( multispace0, expr, space_delimited(opt(tag(","))), )), tag(")"), ))(r)?; Ok((r, Expression::FnInvoke(ident, args))) } fn ident(input: &str) -> IResult<&str, Expression> { let (r, res) = space_delimited(identifier)(input)?; Ok((r, Expression::Ident(res))) } fn identifier(input: &str) -> IResult<&str, &str> { recognize(pair( alt((alpha1, tag("_"))), many0(alt((alphanumeric1, tag("_")))), ))(input) } fn number(input: &str) -> IResult<&str, Expression> { let (r, v) = space_delimited(recognize_float)(input)?; Ok(( r, Expression::NumLiteral(v.parse().map_err( |_| { nom::Err::Error(nom::error::Error { input, code: nom::error::ErrorKind::Digit, }) }, )?), )) } fn parens(i: &str) -> IResult<&str, Expression> { space_delimited( delimited(tag("("), expr, tag(")")) )(i) } fn term(i: &str) -> IResult<&str, Expression> { let (i, init) = factor(i)?; fold_many0( pair(space_delimited(alt((char('*'), char('/')))), factor), move || init.clone(), |acc, (op, val): (char, Expression)| { match op { '*' => Expression::Mul(Box::new(acc), Box::new(val)), '/' => Expression::Div(Box::new(acc), Box::new(val)), _ => panic!( "Multiplicative expression should have '*' or '/' operator" ), } }, )(i) } fn num_expr(i: &str) -> IResult<&str, Expression> { let (i, init) = term(i)?; fold_many0( pair(space_delimited(alt((char('+'), char('-')))), term), move || init.clone(), |acc, (op, val): (char, Expression)| match op { '+' => Expression::Add(Box::new(acc), Box::new(val)), '-' => Expression::Sub(Box::new(acc), Box::new(val)), _ => panic!( "Additive expression should have '+' or '-' operator" ), }, )(i) } fn open_brace(i: &str) -> IResult<&str, ()> { let (i, _) = space_delimited(char('{'))(i)?; Ok((i, ())) } fn close_brace(i: &str) -> IResult<&str, ()> { let (i, _) = space_delimited(char('}'))(i)?; Ok((i, ())) } fn if_expr(i: &str) -> IResult<&str, Expression> { let (i, _) = space_delimited(tag("if"))(i)?; let (i, cond) = expr(i)?; let (i, t_case) = delimited(open_brace, expr, close_brace)(i)?; let (i, f_case) = opt(preceded( space_delimited(tag("else")), delimited(open_brace, expr, close_brace), ))(i)?; Ok(( i, Expression::If( Box::new(cond), Box::new(t_case), f_case.map(Box::new), ), )) } fn expr(i: &str) -> IResult<&str, Expression> { alt((if_expr, num_expr))(i) } fn var_def(i: &str) -> IResult<&str, Statement> { let (i, _) = delimited(multispace0, tag("var"), multispace1)(i)?; let (i, name) = space_delimited(identifier)(i)?; let (i, _) = space_delimited(char('='))(i)?; let (i, expr) = space_delimited(expr)(i)?; Ok((i, Statement::VarDef(name, expr))) } fn var_assign(i: &str) -> IResult<&str, Statement> { let (i, name) = space_delimited(identifier)(i)?; let (i, _) = space_delimited(char('='))(i)?; let (i, expr) = space_delimited(expr)(i)?; Ok((i, Statement::VarAssign(name, expr))) } fn expr_statement(i: &str) -> IResult<&str, Statement> { let (i, res) = expr(i)?; Ok((i, Statement::Expression(res))) } fn for_statement(i: &str) -> IResult<&str, Statement> { let (i, _) = space_delimited(tag("for"))(i)?; let (i, loop_var) = space_delimited(identifier)(i)?; let (i, _) = space_delimited(tag("in"))(i)?; let (i, start) = space_delimited(expr)(i)?; let (i, _) = space_delimited(tag("to"))(i)?; let (i, end) = space_delimited(expr)(i)?; let (i, stmts) = delimited(open_brace, statements, close_brace)(i)?; Ok((i, Statement::For { loop_var, start, end, stmts })) } fn statement(i: &str) -> IResult<&str, Statement> { alt(( for_statement, terminated( alt((var_def, var_assign, expr_statement)), char(';'), ), ))(i) } fn statements(i: &str) -> IResult<&str, Statements> { let (i, stmts) = many0(statement)(i)?; let (i, _) = opt(char(';'))(i)?; Ok((i, stmts)) } fn statements_finish( i: &str, ) -> Result<Statements, nom::error::Error<&str>> { let (_, res) = statements(i).finish()?; Ok(res) }

var a = 1; for i in 0 to 3 { a + i; }

use std::{ collections::HashMap, io::Read }; use nom::{ branch::alt, bytes::complete::tag, character::complete::{ alpha1, alphanumeric1, char, multispace0, multispace1, }, combinator::{opt, recognize}, error::ParseError, multi::{fold_many0, many0, separated_list0}, number::complete::recognize_float, sequence::{delimited, pair, preceded, terminated}, Finish, IResult, Parser, }; fn main() { let mut buf = String::new(); if !std::io::stdin().read_to_string(&mut buf).is_ok() { panic!("Failed to read from stdin"); } let parsed_statements = match statements_finish(&buf) { Ok(parsed_statements) => parsed_statements, Err(e) => { eprintln!("Parse error: {e:?}"); return; } }; let mut frame = StackFrame::new(); eval_stmts(&parsed_statements, &mut frame); } enum FnDef<'src> { User(UserFn<'src>), Native(NativeFn), } impl<'src> FnDef<'src> { fn call(&self, args: &[f64], frame: &StackFrame) -> f64 { match self { Self::User(code) => { let mut new_frame = StackFrame::push_stack(frame); new_frame.vars = args.iter().zip(code.args.iter()).map(|(arg, name)| (name.to_string(), *arg)).collect(); eval_stmts(&code.stmts, &mut new_frame) } Self::Native(code) => (code.code)(args), } } } struct UserFn<'src> { args: Vec<&'src str>, stmts: Statements<'src>, } struct NativeFn { code: Box<dyn Fn(&[f64]) -> f64>, } type Variables = HashMap<String, f64>; type Functions<'src> = HashMap<String, FnDef<'src>>; struct StackFrame<'src> { vars: Variables, funcs: Functions<'src>, uplevel: Option<&'src StackFrame<'src>>, } impl<'src> StackFrame<'src> { fn new() -> Self { let mut funcs = Functions::new(); funcs.insert("sqrt".to_string(), unary_fn(f64::sqrt)); funcs.insert("sin".to_string(), unary_fn(f64::sin)); funcs.insert("cos".to_string(), unary_fn(f64::cos)); funcs.insert("tan".to_string(), unary_fn(f64::tan)); funcs.insert("asin".to_string(), unary_fn(f64::asin)); funcs.insert("acos".to_string(), unary_fn(f64::acos)); funcs.insert("atan".to_string(), unary_fn(f64::atan)); funcs.insert("atan2".to_string(), binary_fn(f64::atan2)); funcs.insert("pow".to_string(), binary_fn(f64::powf)); funcs.insert("exp".to_string(), unary_fn(f64::exp)); funcs.insert("log".to_string(), binary_fn(f64::log)); funcs.insert("log10".to_string(), unary_fn(f64::log10)); funcs.insert("print".to_string(), unary_fn(print)); Self { vars: Variables::new(), funcs, uplevel: None, } } fn push_stack(uplevel: &'src Self) -> Self { Self { vars: HashMap::new(), funcs: HashMap::new(), uplevel: Some(uplevel), } } fn get_fn(&self, name: &str) -> Option<&FnDef<'src>> { let mut next_frame = Some(self); while let Some(frame) = next_frame { if let Some(func) = frame.funcs.get(name) { return Some(func); } next_frame = frame.uplevel; } None } } fn print(arg: f64) -> f64 { println!("print: {arg}"); 0. } fn eval_stmts<'src>(stmts: &[Statement<'src>], frame: &mut StackFrame<'src>) -> f64 { let mut last_result = 0.; for statement in stmts { match statement { Statement::Expression(expr) => { last_result = eval(expr, frame); } Statement::VarDef(name, expr) => { let value = eval(expr, frame); frame.vars.insert(name.to_string(), value); } Statement::VarAssign(name, expr) => { if !frame.vars.contains_key(*name) { panic!("Variable is not defined"); } let value = eval(expr, frame); frame.vars.insert(name.to_string(), value); } Statement::For { loop_var, start, end, stmts, } => { let start = eval(start, frame) as isize; let end = eval(end, frame) as isize; for i in start..end { frame.vars.insert(loop_var.to_string(), i as f64); eval_stmts(stmts, frame); } } Statement::FnDef { name, args, stmts, } => { frame.funcs.insert( name.to_string(), FnDef::User(UserFn { args: args.clone(), stmts: stmts.clone(), }), ); } } } last_result } #[derive(Debug, PartialEq, Clone)] enum Expression<'src> { Ident(&'src str), NumLiteral(f64), FnInvoke(&'src str, Vec<Expression<'src>>), Add(Box<Expression<'src>>, Box<Expression<'src>>), Sub(Box<Expression<'src>>, Box<Expression<'src>>), Mul(Box<Expression<'src>>, Box<Expression<'src>>), Div(Box<Expression<'src>>, Box<Expression<'src>>), Gt(Box<Expression<'src>>, Box<Expression<'src>>), Lt(Box<Expression<'src>>, Box<Expression<'src>>), If( Box<Expression<'src>>, Box<Expression<'src>>, Option<Box<Expression<'src>>>, ), } #[derive(Debug, PartialEq, Clone)] enum Statement<'src> { Expression(Expression<'src>), VarDef(&'src str, Expression<'src>), VarAssign(&'src str, Expression<'src>), For { loop_var: &'src str, start: Expression<'src>, end: Expression<'src>, stmts: Statements<'src>, }, FnDef { name: &'src str, args: Vec<&'src str>, stmts: Statements<'src>, }, } type Statements<'a> = Vec<Statement<'a>>; fn unary_fn<'a>(f: fn(f64) -> f64) -> FnDef<'a> { FnDef::Native(NativeFn { code: Box::new(move |args| { f(*args.into_iter().next().expect("function missing argument")) }) }) } fn binary_fn<'a>(f: fn(f64, f64) -> f64) -> FnDef<'a> { FnDef::Native(NativeFn { code: Box::new(move |args| { let mut args = args.into_iter(); let lhs = args.next().expect("function missing the first argument"); let rhs = args.next().expect("function missing the second argument"); f(*lhs, *rhs) }) }) } fn eval(expr: &Expression, frame: &StackFrame) -> f64 { use Expression::*; match expr { Ident("pi") => std::f64::consts::PI, Ident(id) => *frame.vars.get(*id).expect("Variable not found"), NumLiteral(n) => *n, FnInvoke(name, args) => { if let Some(func) = frame.get_fn(*name) { let args: Vec<_> = args.iter().map(|arg| eval(arg, frame)).collect(); func.call(&args, frame) } else { panic!("Unknown function {name:?}") } }, Add(lhs, rhs) => eval(lhs, frame) + eval(rhs, frame), Sub(lhs, rhs) => eval(lhs, frame) - eval(rhs, frame), Mul(lhs, rhs) => eval(lhs, frame) * eval(rhs, frame), Div(lhs, rhs) => eval(lhs, frame) / eval(rhs, frame), Gt(lhs, rhs) => { if eval(lhs, frame) > eval(rhs, frame) { 1. } else { 0. } } Lt(lhs, rhs) => { if eval(lhs, frame) < eval(rhs, frame) { 1. } else { 0. } } If(cond, t_case, f_case) => { if eval(cond, frame) != 0. { eval(t_case, frame) } else if let Some(f_case) = f_case { eval(f_case, frame) } else { 0. } } } } fn space_delimited<'src, O, E>( f: impl Parser<&'src str, O, E>, ) -> impl FnMut(&'src str) -> IResult<&'src str, O, E> where E: ParseError<&'src str>, { delimited(multispace0, f, multispace0) } fn factor(i: &str) -> IResult<&str, Expression> { alt((number, func_call, ident, parens))(i) } fn func_call(i: &str) -> IResult<&str, Expression> { let (r, ident) = space_delimited(identifier)(i)?; let (r, args) = space_delimited(delimited( tag("("), many0(delimited( multispace0, expr, space_delimited(opt(tag(","))), )), tag(")"), ))(r)?; Ok((r, Expression::FnInvoke(ident, args))) } fn ident(input: &str) -> IResult<&str, Expression> { let (r, res) = space_delimited(identifier)(input)?; Ok((r, Expression::Ident(res))) } fn identifier(input: &str) -> IResult<&str, &str> { recognize(pair( alt((alpha1, tag("_"))), many0(alt((alphanumeric1, tag("_")))), ))(input) } fn number(input: &str) -> IResult<&str, Expression> { let (r, v) = space_delimited(recognize_float)(input)?; Ok(( r, Expression::NumLiteral(v.parse().map_err( |_| { nom::Err::Error(nom::error::Error { input, code: nom::error::ErrorKind::Digit, }) }, )?), )) } fn parens(i: &str) -> IResult<&str, Expression> { space_delimited( delimited(tag("("), expr, tag(")")) )(i) } fn term(i: &str) -> IResult<&str, Expression> { let (i, init) = factor(i)?; fold_many0( pair(space_delimited(alt((char('*'), char('/')))), factor), move || init.clone(), |acc, (op, val): (char, Expression)| { match op { '*' => Expression::Mul(Box::new(acc), Box::new(val)), '/' => Expression::Div(Box::new(acc), Box::new(val)), _ => panic!( "Multiplicative expression should have '*' or '/' operator" ), } }, )(i) } fn num_expr(i: &str) -> IResult<&str, Expression> { let (i, init) = term(i)?; fold_many0( pair(space_delimited(alt((char('+'), char('-')))), term), move || init.clone(), |acc, (op, val): (char, Expression)| match op { '+' => Expression::Add(Box::new(acc), Box::new(val)), '-' => Expression::Sub(Box::new(acc), Box::new(val)), _ => panic!( "Additive expression should have '+' or '-' operator" ), }, )(i) } fn cond_expr(i: &str) -> IResult<&str, Expression> { let (i, first) = num_expr(i)?; let (i, cond) = space_delimited(alt((char('<'), char('>'))))(i)?; let (i, second) = num_expr(i)?; Ok(( i, match cond { '<' => Expression::Lt(Box::new(first), Box::new(second)), '>' => Expression::Gt(Box::new(first), Box::new(second)), _ => unreachable!(), }, )) } fn open_brace(i: &str) -> IResult<&str, ()> { let (i, _) = space_delimited(char('{'))(i)?; Ok((i, ())) } fn close_brace(i: &str) -> IResult<&str, ()> { let (i, _) = space_delimited(char('}'))(i)?; Ok((i, ())) } fn if_expr(i: &str) -> IResult<&str, Expression> { let (i, _) = space_delimited(tag("if"))(i)?; let (i, cond) = expr(i)?; let (i, t_case) = delimited(open_brace, expr, close_brace)(i)?; let (i, f_case) = opt(preceded( space_delimited(tag("else")), delimited(open_brace, expr, close_brace), ))(i)?; Ok(( i, Expression::If( Box::new(cond), Box::new(t_case), f_case.map(Box::new), ), )) } fn expr(i: &str) -> IResult<&str, Expression> { alt((if_expr, cond_expr, num_expr))(i) } fn var_def(i: &str) -> IResult<&str, Statement> { let (i, _) = delimited(multispace0, tag("var"), multispace1)(i)?; let (i, name) = space_delimited(identifier)(i)?; let (i, _) = space_delimited(char('='))(i)?; let (i, expr) = space_delimited(expr)(i)?; Ok((i, Statement::VarDef(name, expr))) } fn var_assign(i: &str) -> IResult<&str, Statement> { let (i, name) = space_delimited(identifier)(i)?; let (i, _) = space_delimited(char('='))(i)?; let (i, expr) = space_delimited(expr)(i)?; Ok((i, Statement::VarAssign(name, expr))) } fn expr_statement(i: &str) -> IResult<&str, Statement> { let (i, res) = expr(i)?; Ok((i, Statement::Expression(res))) } fn for_statement(i: &str) -> IResult<&str, Statement> { let (i, _) = space_delimited(tag("for"))(i)?; let (i, loop_var) = space_delimited(identifier)(i)?; let (i, _) = space_delimited(tag("in"))(i)?; let (i, start) = space_delimited(expr)(i)?; let (i, _) = space_delimited(tag("to"))(i)?; let (i, end) = space_delimited(expr)(i)?; let (i, stmts) = delimited(open_brace, statements, close_brace)(i)?; Ok((i, Statement::For { loop_var, start, end, stmts })) } fn fn_def_statement(i: &str) -> IResult<&str, Statement> { let (i, _) = space_delimited(tag("fn"))(i)?; let (i, name) = space_delimited(identifier)(i)?; let (i, _) = space_delimited(tag("("))(i)?; let (i, args) = separated_list0(char(','), space_delimited(identifier))(i)?; let (i, _) = space_delimited(tag(")"))(i)?; let (i, stmts) = delimited(open_brace, statements, close_brace)(i)?; Ok((i, Statement::FnDef { name, args, stmts })) } fn statement(i: &str) -> IResult<&str, Statement> { alt(( for_statement, fn_def_statement, terminated( alt((var_def, var_assign, expr_statement)), char(';'), ), ))(i) } fn statements(i: &str) -> IResult<&str, Statements> { let (i, stmts) = many0(statement)(i)?; let (i, _) = opt(char(';'))(i)?; Ok((i, stmts)) } fn statements_finish( i: &str, ) -> Result<Statements, nom::error::Error<&str>> { let (_, res) = statements(i).finish()?; Ok(res) }

fn add(a, b) { a + b; } print(add(1, 2));

let mut frame = StackFrame::new();

println!("parsed_statements: {:?}", parsed_statements);

parsed_statements: [ FnDef { name: "add", args: ["a", "b"], stmts: [Expression(Add(Ident("a"), Ident("b")))] }, Expression ( FnInvoke("print", [FnInvoke("add", [NumLiteral(1.0), NumLiteral(2.0)])]) ) ]