lazy initialization for placeholder parser

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch/Parsers/ParserWithLookahead.cs

@@ -6,7 +6,7 @@ namespace SimpleStateMachine.StructuralSearch
 {
     public abstract class ParserWithLookahead<TToken, T> : Parser<TToken, T>
     {
-        private Parser<TToken, T> _parser { get; set; }
+        private Func<Parser<TToken, T>> _parser { get; set; }
 
         public Func<IEnumerable<LookaheadResult<TToken, T>>> OnLookahead { get; set; }
 
@@ -15,13 +15,14 @@ public abstract Parser<TToken, T> BuildParser(Func<Parser<TToken, T>?> next,
 
         public void Lookahead(Func<Parser<TToken, T>?> next, Func<Parser<TToken, T>?> nextNext)
         {
-            _parser = BuildParser(next, nextNext);
+            // lazy initialization
+            _parser = () => BuildParser(next, nextNext);
         }
 
         public override bool TryParse(ref ParseState<TToken> state, ref PooledList<Expected<TToken>> expected,
             out T result)
         {
-            var res = _parser.TryParse(ref state, ref expected, out result);
+            var res = _parser().TryParse(ref state, ref expected, out result);
             return res;
         }
     }

src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs

@@ -34,7 +34,7 @@ public override Parser<char, string> BuildParser(Func<Parser<char, string>> next
             var anyString = CommonTemplateParser.AnyCharWithPlshd
                 .AtLeastOnceAsStringUntil(lookahead);
 
-            var simpleString = CommonTemplateParser.StringWithPlshd.Labelled("simpleString");
+            var simpleString = CommonTemplateParser.StringWithPlshd;
             var token = Parser.OneOf(simpleString, CommonParser.WhiteSpaces).Try();
             Parser<char, string> term = null;
 
@@ -57,11 +57,20 @@ public override Parser<char, string> BuildParser(Func<Parser<char, string>> next
         public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expected,
             out string result)
         {
-            var res = base.TryParse(ref state, ref expected, out result);
-
-            if (res)
-                res &= _context.TryAdd(Name, result);
-
+            bool res;
+            
+            // No use look-ahead if placeholder is already defined
+            if (_context.TryGet(Name, out var value))
+            {
+                res = Parser.String(value).TryParse(ref state, ref expected, out result);
+            }
+            else
+            {
+                res = base.TryParse(ref state, ref expected, out result);
+                if (res)
+                    _context.AddPlaceholder(Name, result);
+            }
+            
             return res;
         }
 

src/SimpleStateMachine.StructuralSearch/Parsers/SeriesParser.cs

@@ -38,9 +38,9 @@ public override bool TryParse(ref ParseState<TToken> state, ref PooledList<Expec
 
                 void SkipLookedParsers(Parser<TToken, T> parser, ref ParseState<TToken> state)
                 {
-                    if (parser is not ParserWithLookahead<TToken, T> lookaheadParser) 
+                    if (parser is not ParserWithLookahead<TToken, T> lookaheadParser || lookaheadParser is { OnLookahead: null }) 
                         return;
-            
+                    
                     var lookaheadResults = lookaheadParser.OnLookahead.Invoke();
 
                     foreach (var result in lookaheadResults)
@@ -49,7 +49,8 @@ void SkipLookedParsers(Parser<TToken, T> parser, ref ParseState<TToken> state)
                         state.Advance(result.TokensCount);
                         i++;
                     }
-            
+                    
+                    //recursion
                     foreach (var result in lookaheadResults)
                     {
                         SkipLookedParsers(result.Parser, ref state);

src/SimpleStateMachine.StructuralSearch/ParsingContext.cs

@@ -6,14 +6,14 @@ public class ParsingContext
     {
         public Dictionary<string, string> Placeholders { get; } = new();
 
-        public bool TryAdd(string name, string value)
+        public bool TryGet(string name, out string value)
         {
-            if (Placeholders.ContainsKey(name))
-                return Placeholders[name] == value;
-
-            Placeholders.Add(name, value);
-            
-            return true;
+            return Placeholders.TryGetValue(name, out value);
+        }
+        
+        public void AddPlaceholder(string name, string value)
+        {
+           Placeholders[name] = value;
         }
 
         public string GetPlaceholder(string name)