martials/simplify_truths
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Simplifies some parsing functions

Browse Source
This commit is contained in:
Martin Berg Alstad 2024-07-31 19:39:01 +02:00
parent ee86e3be2f
commit 1350e09bde
1 changed files with 34 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
src/parsing/expression_parser.rs
View File

@ -3,10 +3,10 @@ use lib::traits::IntoResult;
use nom::branch::alt; use nom::branch::alt;
use nom::bytes::complete::{tag, take_while, take_while1}; use nom::bytes::complete::{tag, take_while, take_while1};
use nom::character::complete::char; use nom::character::complete::char;
use nom::combinator::{opt, peek}; use nom::combinator::{map, opt, peek};
use nom::error::Error; use nom::error::Error;
use nom::IResult;
use nom::sequence::{pair, preceded}; use nom::sequence::{pair, preceded};
use nom::IResult;
use crate::expressions::expression::Expression; use crate::expressions::expression::Expression;
use crate::expressions::helpers::atomic; use crate::expressions::helpers::atomic;
@ -41,15 +41,15 @@ fn expression<'a>(previous: Expression) -> impl Fn(&'a str) -> IResult<&'a str,
} }
} }
fn operator_combinators(expression: Expression) -> impl Fn(&str) -> IResult<&str, Expression> { fn operator_combinators<'a>(
move |input: &str| { expression: Expression,
alt(( ) -> impl FnMut(&'a str) -> IResult<&'a str, Expression> {
implication_expression(expression.clone()), alt((
or_expression(expression.clone()), implication_expression(expression.clone()),
and_expression(expression.clone()), or_expression(expression.clone()),
not_expression, and_expression(expression.clone()),
))(input) not_expression,
} ))
} }
fn parenthesized_expression(input: &str) -> IResult<&str, Expression> { fn parenthesized_expression(input: &str) -> IResult<&str, Expression> {
@ -64,11 +64,10 @@ fn parenthesized_expression(input: &str) -> IResult<&str, Expression> {
})(input) })(input)
} }
fn and_expression<'a>(previous: Expression) -> impl Fn(&'a str) -> IResult<&'a str, Expression> { fn and_expression<'a>(previous: Expression) -> impl FnMut(&'a str) -> IResult<&'a str, Expression> {
move |input: &'a str| { map(preceded(trim(char('&')), left_hand_side), move |right| {
preceded(trim(char('&')), left_hand_side)(input) previous.clone().and(right)
.map(|(remaining, right)| (remaining, previous.clone().and(right))) })
}
} }
fn complete_and(input: &str) -> IResult<&str, Expression> { fn complete_and(input: &str) -> IResult<&str, Expression> {
@ -76,11 +75,11 @@ fn complete_and(input: &str) -> IResult<&str, Expression> {
and_expression(atomic.clone())(remaining) and_expression(atomic.clone())(remaining)
} }
fn or_expression<'a>(previous: Expression) -> impl Fn(&'a str) -> IResult<&'a str, Expression> { fn or_expression<'a>(previous: Expression) -> impl FnMut(&'a str) -> IResult<&'a str, Expression> {
move |input: &'a str| { map(
preceded(trim(char('|')), alt((complete_and, left_hand_side)))(input) preceded(trim(char('|')), alt((complete_and, left_hand_side))),
.map(|(remaining, right)| (remaining, previous.clone().or(right))) move |right| previous.clone().or(right),
} )
} }
fn complete_or(input: &str) -> IResult<&str, Expression> { fn complete_or(input: &str) -> IResult<&str, Expression> {
@ -90,14 +89,14 @@ fn complete_or(input: &str) -> IResult<&str, Expression> {
fn implication_expression<'a>( fn implication_expression<'a>(
previous: Expression, previous: Expression,
) -> impl Fn(&'a str) -> IResult<&'a str, Expression> { ) -> impl FnMut(&'a str) -> IResult<&'a str, Expression> {
move |input: &'a str| { map(
preceded( preceded(
trim(tag("=>")), trim(tag("=>")),
alt((complete_and, complete_or, left_hand_side)), alt((complete_and, complete_or, left_hand_side)),
)(input) ),
.map(|(remaining, right)| (remaining, previous.clone().implies(right))) move |right| previous.clone().implies(right),
} )
} }
fn not_expression(input: &str) -> IResult<&str, Expression> { fn not_expression(input: &str) -> IResult<&str, Expression> {
@ -105,14 +104,16 @@ fn not_expression(input: &str) -> IResult<&str, Expression> {
} }
fn value(input: &str) -> IResult<&str, Expression> { fn value(input: &str) -> IResult<&str, Expression> {
pair( map(
take_while1(|c: char| c.is_ascii_alphabetic()), pair(
take_while(|c: char| c.is_ascii_alphanumeric() || c == '_'), take_while1(|c: char| c.is_ascii_alphabetic()),
take_while(|c: char| c.is_ascii_alphanumeric() || c == '_'),
),
|(first, rest)| {
let value = format!("{first}{rest}");
atomic(value)
},
)(input) )(input)
.map(|(remaining, (first, rest))| {
let value = format!("{first}{rest}");
(remaining, atomic(value))
})
} }
#[cfg(test)] #[cfg(test)]