C# Online Compiler | .NET Fiddle

using System;
using Sprache;
using System.Linq;
using System.Collections.Generic;

namespace dotnet_parser
{
    class Program
    {
        /*
            ex := op '(' pr ')'             //expression
            pr := id ',' lt | ex (',' ex)*  //parameter (* means zero or more)
            op := string                    //operator
            id := string                    //id
            lt := quoted-string | number    //literal
        */

        static void Main(string[] args)
        {
            var ex = Parser.getEx().Parse(@"
                                            OR(
                                                AND(
                                                    EQUAL(title, ""Foo""),
                                                    AND(
                                                        GREATER_THAN(views, 50),
                                                        EQUAL(timestamp, 123456789)
                                                    )
                                                ),
                                                EQUAL(id, ""123"")
                                            )");
            
            var sd =
                new StoreData
                {
                    id = "321",
                    title = "Foo",
                    views = 49,
                    timestamp = 123456789
                };

            var res = Calc.Run(ex, sd);

            Console.WriteLine($"result {res}");
        }

        public class StoreData 
        {
            public string id { get; set; }
            public string title { get; set; }
            public string content { get; set; }
            public int views { get; set; }
            public int timestamp { set; get; }
        }

        public class Calc {
            public static bool Run<T>(Parser.Ex ex, T t) {

                switch(ex.Op) {
                    case "NOT":
                    {
                        if(ex.Pr is Parser.PrEx exPr && exPr.Ex.Length == 1) {
                            return Run(exPr.Ex[0], t);
                        }
                        else {
                            throw new Exception($"invalid parameters to {ex.Op}");
                        }
                    }
                    case "AND":
                    case "OR":
                    {
                        if(ex.Pr is Parser.PrEx exPr && exPr.Ex.Length == 2) {
                            var l = Run(exPr.Ex[0], t);
                            var r = Run(exPr.Ex[1], t);
                            switch(ex.Op) {
                                case "AND": return l && r;
                                case "OR" : return l || r;
                                default:
                                    throw new Exception();
                            }
                        }
                        else {
                            throw new Exception($"invalid parameters to {ex.Op}");
                        }
                    }
                    case "EQUAL":
                    case "GREATER_THAN":
                    case "LESS_THAN":
                    {
                        if(ex.Pr is Parser.PrIdLt exIdLt) {
                            var tt = typeof(T);
                            var p = tt.GetProperty(exIdLt.Id);

                            if(p == null) throw new Exception($"no property {exIdLt.Id} on {tt.Name}");


                            if(p.PropertyType == typeof(string) && exIdLt.Lt is Parser.LtQuotedString ltQuotedString){
                                var pval = p.GetValue(t) as string;
                                switch(ex.Op){
                                    case "EQUAL":
                                        return pval == ltQuotedString.Val;
                                    default:
                                        throw new Exception($"{ex.Op} invalid operator for string");
                                }
                            }
                            else if(p.PropertyType == typeof(int) && exIdLt.Lt is Parser.LtNumber ltNumber){
                                var pval = (int)p.GetValue(t);

                                int lval;
                                if(!int.TryParse(ltNumber.Val, out lval)) throw new Exception($"{ex.Op} {exIdLt.Id} {ltNumber.Val} is not a number");

                                switch(ex.Op){
                                    case "EQUAL"       : return pval == lval;
                                    case "GREATER_THAN": return pval >  lval;
                                    case "LESS_THAN"   : return pval <  lval;
                                    default:
                                        throw new Exception($"{ex.Op} invalid operator for string");
                                }
                            }
                            else {
                                throw new Exception($"{ex.Op} {exIdLt.Id} invalid type");
                            }
                        }
                        else {
                            throw new Exception($"invalid parameters to {ex.Op}");
                        }
                    }
                    default:
                        throw new Exception($"{ex.Op} unknown operator");
                }
            }
        }

        public class Parser {
            public class Ex {
                public string Op { get; set; }
                public Pr Pr { get; set; }
            }

            public interface Pr { }
            public class PrIdLt : Pr { 
                public string Id { get; set; }
                public Lt Lt { get; set; }
            }
            public class PrEx : Pr {
                public Ex[] Ex { get; set; }
            }

            public interface Lt { }
            public class LtQuotedString : Lt { public string Val { get; set; } }
            public class LtNumber       : Lt { public string Val { get; set; } }

            public static Parser<Ex> getEx(){
                return
                    from o in getOp()
                    from p in getPr().Contained(Parse.Char('('), Parse.Char(')')).Token()
                    select new Ex { Op = o, Pr = p };

            }
            public static Parser<Pr> getPr(){
                var a =
                    from i in getId()
                    from c in Parse.Char(',').Token()
                    from l in getLt()
                    select new PrIdLt { Id = i, Lt = l };

                var b =
                    from ex in Parse.Ref(() => getEx())
                    from em in Parse.Char(',').Token().Then(_ => Parse.Ref(() => getEx())).Many()
                    select new PrEx { Ex = em.Prepend(ex).ToArray() };

                return a.Or<Pr>(b);
            }
            public static Parser<string> getOp() => Parse.Letter.Or(Parse.Char('_')).AtLeastOnce().Text().Token();
            public static Parser<string> getId() => Parse.Identifier(Parse.Letter, Parse.LetterOrDigit).Token();
            public static Parser<Lt> getLt(){
                var quoted_string =
                    from open in Parse.Char('"')
                    from value in Parse.CharExcept('"').Many().Text()
                    from close in Parse.Char('"')
                    select value;

                return
                    quoted_string.Select(a => new LtQuotedString { Val = a })
                    .Or<Lt>(Parse.Number.Select(a => new LtNumber(){ Val = a })).Token();
            }
        }
    }
}

                                if(!int.TryParse(ltNumber.Val, out lval)) throw new Exception($"{ex.Op} {exIdLt.Id} {ltNumber.Val} is not a number");
 
using System;
using Sprache;
using System.Linq;
using System.Collections.Generic;
​
namespace dotnet_parser
{
    class Program
    {
        /*
            ex := op '(' pr ')'             //expression
            pr := id ',' lt | ex (',' ex)*  //parameter (* means zero or more)
            op := string                    //operator
            id := string                    //id
            lt := quoted-string | number    //literal
        */
​
        static void Main(string[] args)
        {
            var ex = Parser.getEx().Parse(@"
                                            OR(
                                                AND(
                                                    EQUAL(title, ""Foo""),
                                                    AND(

Cached Result

Environment version: .NET 9.0.0 (9.0.0, Unix 6.8.0.1014)

<Root>
<inf>–CO–OR</inf>
</Root>
<?xml version="1.0" encoding="us-ascii"?>
<Root>
<inf>–CO–OR</inf>
</Root>