Atomize 1.1.0

Atomize/__Quickstart__

Atomize is a combinatory parser building library supporting the standard PEG operators, as well as:

• Positive and negative look-behind
• Directly and indirectly left recursive parsers

Installation

Atomize can be installed via NuGet or

dotnet add package Atomize

Documentation

User Guide
References

Example: BasicCalculator

Implementing a parser based on the following grammar:

Additive
: Additive /[+-]/ Multiplicative
| Multiplicative;

Multiplicative
: Multiplicative /[*\/]/ Atomic
| Atomic;

Atomic
: NUMBER
| '(' Additive ')';

using static Atomize.Parse;

public static class BasicCalculator
{
   private static readonly Parser<double> Atomic = 
      Choice(
         from n in Text.Number 
         select double.Parse(n.Span),

         Island(Atom('('), Ref(() => Additive!), Atom(')'))
      );

   private static readonly Parser<double> Multiplicative = 
      DirectLeftRecursion(
         Choice(
            from left in Ref(() => Multiplicative!)
            from op in Choice(Atom('*'), Atom('/')),
            from right in Atomic
            select op == '*'
               ? left * double.Parse(right.Span)
               : left / double.Parse(right.Span),
            
            Atomic
         )
      );    
   
   private static readonly Parser<double> Additive =
      DirectLeftRecursion(
         Choice(
            from left in Ref(() => Additive!)
            from op in Choice(Atom('+'), Atom('-')),
            from right in Multiplicative
            select op == '+'
               ? left + double.Parse(right.Span)
               : left - double.Parse(right.Span),
            
            Multiplicative)); 

   public static IParseResult<double> Apply(TextScanner expr) => 
      Additive(expr);
}