template parser

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Sandbox/Extensions/EnumerableCharExtensions.cs

@@ -13,5 +13,17 @@ public static Parser<Ttoken, string> AsString<Ttoken>(this Parser<Ttoken, IEnume
         {
             return parser.Select(x => new string(x.ToArray()));
         }
+
+        public static Parser<Ttoken, IEnumerable<T>> MergerMany<Ttoken, T>(
+            this Parser<Ttoken, IEnumerable<IEnumerable<T>>> parser)
+        {
+            return parser.Select(x => x.SelectMany(y => y));
+        }
+        
+        public static Parser<Ttoken, IEnumerable<T>> MergerMany<Ttoken, T>(
+            this Parser<Ttoken, IEnumerable<List<T>>> parser)
+        {
+            return parser.Select(x => x.SelectMany(y => y));
+        }
     }
 }

src/SimpleStateMachine.StructuralSearch.Sandbox/Extensions/StringParserExtensions.cs

@@ -34,13 +34,13 @@ public static Parser<TToken, string> BetweenAsThen<TToken>(this Parser<TToken, s
                 parser1, parser, parser2);
         }
 
-        // public static Parser<TToken, IEnumerable<string>> ToMany<TToken>(this Parser<TToken, string> parser)
-        // {
-        //     return parser.Select(x => new List<string>() { x }).ToIEnumerable();
-        // }
-        public static Parser<TToken, List<string>> ToMany<TToken>(this Parser<TToken, string> parser)
+        public static Parser<TToken, IEnumerable<string>> ToMany<TToken>(this Parser<TToken, string> parser)
         {
-            return parser.Select(x => new List<string>{ x });
+            return parser.Select(x => new List<string>() { x }).ToIEnumerable();
         }
+        // public static Parser<TToken, List<string>> ToMany<TToken>(this Parser<TToken, string> parser)
+        // {
+        //     return parser.Select(x => new List<string>{ x });
+        // }
     }
 }

src/SimpleStateMachine.StructuralSearch.Sandbox/Parsers.cs

@@ -22,23 +22,6 @@ public static Parser<TToken, List<T>> MapToMany<TToken, T>(Parser<TToken, T> par
             return Map((arg1, arg2, arg3) => new List<T>{arg1, arg2, arg3}, parser1, parser2, parser2);
         }
 
-        public static Parser<TToken, List<T>> MapToMany<TToken, T>(Parser<TToken, T> parser1, Parser<TToken, List<T>> parser2, Parser<TToken, T> parser3)
-        {
-            if (parser1 == null)
-                throw new ArgumentNullException(nameof(parser1));
-            if (parser2 == null)
-                throw new ArgumentNullException(nameof(parser2));
-            if (parser3 == null)
-                throw new ArgumentNullException(nameof(parser2));
-            
-            return Map((arg1, arg2, arg3) =>
-            {
-                arg2.Insert(0, arg1);
-                arg2.Add(arg3);
-                return arg2;
-            }, parser1, parser2, parser3);
-        }
-        
         public static Parser<TToken, List<T>> MapToMany<TToken, T>(Parser<TToken, T> parser1, Parser<TToken, IEnumerable<T>> parser2, Parser<TToken, T> parser3)
         {
             if (parser1 == null)
@@ -56,5 +39,6 @@ public static Parser<TToken, List<T>> MapToMany<TToken, T>(Parser<TToken, T> par
                 return result;
             }, parser1, parser2, parser3);
         }
+        
     }
 }

src/SimpleStateMachine.StructuralSearch.Sandbox/Program.cs

@@ -30,40 +30,41 @@ public Placeholder(bool isCorrect, string value)
 
         static void Main(string[] args)
         {
-            var whitespaces = WhitespaceString;
-            var endOfLines = EndOfLine.ManyString();
+            var whitespaces = Char(' ').AtLeastOnceString();
+            var endOfLines = EndOfLine.AtLeastOnceString();
             var anyCharExcept = AnyCharExcept('(', ')', '[', ']', '{', '}', '$', ' ', '\n').AtLeastOnceString().Try()
                 .WithDebug("anyCharExcept");
             Parser<char, IEnumerable<string>> expr = null;
+           
+
             var placeholder = PlaceholderParser.Identifier.Between(Char('$')).Try()
                 .WithDebug("placeholder");
+            
+            // var parenthesised1 = Rec(() => expr).Between(Char('('), Char(')')).WithDebug("parenthesised1");
             var parenthesised1 = MapToMany(Stringc('('), Rec(() => expr), Stringc(')'))
                 .WithDebug("parenthesised1");
+            // var parenthesised2 = Rec(() => expr).Between(Char('['), Char(']')).WithDebug("parenthesised1");
             var parenthesised2 = MapToMany(Stringc('['), Rec(() => expr), Stringc(']'))
                 .WithDebug("parenthesised2");
+            // var parenthesised3 = Rec(() => expr).Between(Char('{'), Char('}')).WithDebug("parenthesised1");
             var parenthesised3 = MapToMany(Stringc('{'), Rec(() => expr), Stringc('}'))
                 .WithDebug("parenthesised3");
+
+            var parenthesised = OneOf(parenthesised1, parenthesised2, parenthesised3).ToIEnumerable();
+            
+            
+            //don't work
+            var parser = OneOf(anyCharExcept, placeholder, whitespaces, endOfLines).AtLeastOnce();
+            expr = parser.Or(parenthesised).AtLeastOnce().MergerMany();
+            
+            //work
+            // var parser = OneOf(anyCharExcept, placeholder).AtLeastOnce();
+            // expr = parser.Or(parenthesised).Separated(Whitespaces).MergerMany();
 
-            // var parenthesised1 = Rec(() => expr)
-            //     .Between(Char('('), Char(')'))
-            //     .WithDebug("parenthesised1");
-            // var parenthesised2 = Rec(() => expr)
-            //     .Between(Char('['), Char(']'))
-            //     .WithDebug("parenthesised1");
-            // var parenthesised3 = Rec(() => expr)
-            //     .Between(Char('{'), Char('}'))
-            //     .WithDebug("parenthesised1");
 
-            var parenthesised = parenthesised1.Or(parenthesised2).Or(parenthesised3);
-
-            // var parser = anyCharExcept.Or(placeholder).Or(whitespaces).Or(endOfLines).Many();
-            var parser = anyCharExcept.Or(placeholder).Separated(Whitespaces);
-
-            expr = parser.Or(parenthesised.ToIEnumerable());
-
-
             var t = "((test > 25) && (test < 50))";
             var t2 = "([test > 25] && {test < 50})";
+            
             //template parser
             var separator = Whitespaces.AsString().Or(EndOfLine);
             var any = AnyCharExcept('$', ' ', '\n').AtLeastOnceString();