Struct parsit::parser::Parsit

pub struct Parsit<'a, T>where
    T: Logos<'a, Source = str>,{ /* private fields */ }

The base structure of the parser combinator that providers a set of methods to construct a gramma

To construct the parser it takes a token set from Logos typically as an Enum

 use logos::Logos;
 use crate::parsit::parser::Parsit;
 #[derive(Logos,PartialEq)]
    pub enum TFQ {
        #[token("true")]
        True,
        #[token("false")]
        False,

        #[token("?")]
        Question,
    }
 let p:Parsit<TFQ> = Parsit::new("true?").unwrap();

Note: The parser works only with string input

Implementations

impl<'a, Token> Parsit<'a, Token>where Token: Logos<'a, Source = str> + PartialEq,

pub fn new(src: &'a str) -> Result<Self, ParseError<'a>>where Token::Extras: Default,

Creates a parser with aset of tokens from the source Raises an error if lexer raises an error

pub fn token(&self, pos: usize) -> Result<(&Token, usize), ParseError<'a>>

obtain a token from the parsing output according to the position number

Arguments

• pos position number

Examples

typically used in the token! macros:

 let p:Parsit<_> = Parsit::new(...)?;
 token!(p.token(0) => ...)

pub fn one_or_more<T, Then>(&self, pos: usize, then: Then) -> Step<'a, Vec<T>>where Then: FnOnce(usize) -> Step<'a, T> + Copy,

executes some rule one or more times shifting the cursor farther. The operator expects at least one occurance of the given function

Arguments

• pos - starting postion to parse
• then - parsing function

Examples

 use logos::Logos;
 use crate::parsit::parser::Parsit;
 use crate::parsit::token;
 use crate::parsit::step::Step;
 #[derive(Logos,PartialEq)]
    pub enum TFQ {
        #[token("true")]
        True,
        #[token("false")]
        False,

        #[token("?")]
        Question,
    }
 let parser:Parsit<TFQ> = Parsit::new("true?false").unwrap();
 let parser_fn = |p|{ token!( parser.token(p) =>
                  TFQ::True => Some(true),
                  TFQ::False => Some(false),
                  TFQ::Question => None
            )};

  if let Some(res) = parser.one_or_more(0, parser_fn).ok() {
    assert_eq!(res, vec![Some(true), None, Some(false)]);
  } else { assert!(false) };

pub fn zero_or_more<T, Then>(&self, pos: usize, then: Then) -> Step<'a, Vec<T>>where Then: FnOnce(usize) -> Step<'a, T> + Copy,

executes some rule one or more times shifting the cursor farther. The operator expects zero or more occurances of the given function

Arguments

• pos - starting postion to parse
• then - parsing function

Examples

 use logos::Logos;
 use crate::parsit::parser::Parsit;
 use crate::parsit::token;
 use crate::parsit::step::Step;
 #[derive(Logos,PartialEq)]
    pub enum TFQ {
        #[token("true")]
        True,
        #[token("false")]
        False,

        #[token("?")]
        Question,
    }
 let parser:Parsit<TFQ> = Parsit::new("").unwrap();
 let parser_fn = |p|{ token!( parser.token(p) =>
                  TFQ::True => Some(true),
                  TFQ::False => Some(false),
                  TFQ::Question => None
            )};

  if let Some(res) = parser.zero_or_more(0, parser_fn).ok() {
    assert_eq!(res, vec![]);
  } else { assert!(false) };

pub fn validate_eof<T>(&self, res: Step<'a, T>) -> Step<'a, T>

Validates if the parsing process reaches the end of the input. If so transforms the result to the error UnreachedEOF

It can be used in the end of the parsing

pub fn env<T>(&self, step: &Step<'a, T>) -> String

Prints a position and env from the source text. It has a radius of 2 tokens so thus it prints -3-2-10+1+2+3