Fix parenthesised parser, fix placeholder parser

RomanSoloweow · RomanSoloweow · commit 64ca5062bbd1 · 2022-03-10T03:38:28.000+03:00
diff --git a/src/SimpleStateMachine.StructuralSearch.Sandbox/Program.cs b/src/SimpleStateMachine.StructuralSearch.Sandbox/Program.cs
@@ -1,11 +1,20 @@
-﻿using Pidgin;
+﻿using System;
+using Pidgin;
+using SimpleStateMachine.StructuralSearch.Extensions;
+using static Pidgin.Parser;
+using static Pidgin.Parser<char>;
 
 namespace SimpleStateMachine.StructuralSearch.Sandbox
 {
     internal static class Program
     {
         static void Main(string[] args)
         {
+            var test = Parser.OneOf(String("Test"), CommonParser.Empty);
+            var res = test.ParseOrThrow("");
+            // var lookahead = Parser.Lookahead(Char(';').Then(End).Try());
+            // var t = Parser.String("return ").Then(Any.AtLeastOnceAsStringUntilNot(lookahead));
+            // var res = t.ParseOrThrow("return 124;;");
             // var testTempalte = "if($test$)";
             // var testText = "if((value1)&&(value2))";
             // var testTextForMatch = "fdjkfnafdjankfjnafkajndaif((value1)&&(value2))";
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/FindTemplateTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/FindTemplateTests.cs
@@ -20,13 +20,13 @@ public void TemplateParsingShouldBeSuccess(string templatePath)
         
         [Theory]
         [InlineData("Templates/IfElseTemplate.txt", "Sources/IfElseSource.txt")]
-        [InlineData("Templates/IfValueIsNullTemplate.txt", "Templates/IfValueIsNullSource.txt")]
-        [InlineData("Templates/NestedParenthesisedTemplate.txt", "Templates/NestedParenthesisedSource.txt")]
+        [InlineData("Templates/IfValueIsNullTemplate.txt", "Sources/IfValueIsNullSource.txt")]
+        [InlineData("Templates/NestedParenthesisedTemplate.txt", "Sources/NestedParenthesisedSource.txt")]
         public void SourceParsingBeTemplateShouldBeSuccess(string templatePath, string sourcePath)
         {
             var templateStr = File.ReadAllText(templatePath);
-            var sourceStr = File.ReadAllText(templatePath);
-            
+            var sourceStr = File.ReadAllText(sourcePath);
+
             var template = StructuralSearch.ParseTemplate(templateStr);
             var result = template.ParseOrThrow(sourceStr);
             
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/PlaceholderParserTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/PlaceholderParserTests.cs
@@ -0,0 +1,22 @@
+﻿using Pidgin;
+using Xunit;
+
+namespace SimpleStateMachine.StructuralSearch.Tests
+{
+    public class PlaceholderParserTests
+    {
+        // [Theory]
+        // [InlineData("($test$)", "(value )", "value ")]
+        // [InlineData("($test$ )", "(value )", "value")]
+        // [InlineData("($test$)", "(value (test))", "value (test)")]
+        // public void TemplateParsingShouldBeSuccess(string template, string source, string result)
+        // {
+        //     var templateParser = StructuralSearch.ParseTemplate(template);
+        //     var res = templateParser.ParseOrThrow(source);
+        //     // var templateStr = File.ReadAllText(templatePath);
+        //     // var template = StructuralSearch.ParseTemplate(templateStr);
+        //     //
+        //     // Assert.NotNull(template);
+        // }
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/Sources/IfValueIsNullSource.txt b/src/SimpleStateMachine.StructuralSearch.Tests/Sources/IfValueIsNullSource.txt
@@ -1,4 +1,4 @@
 ﻿if(temp == null)
 {
-    temp = new List<string>();
+    temp = 12;
 }
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/Sources/NestedParenthesisedSource.txt b/src/SimpleStateMachine.StructuralSearch.Tests/Sources/NestedParenthesisedSource.txt
@@ -1 +1 @@
-﻿((value1) && (value2))
+﻿(((value1) && (value2)) && (value1) && (value2))
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/Templates/IfValueIsNullTemplate.txt b/src/SimpleStateMachine.StructuralSearch.Tests/Templates/IfValueIsNullTemplate.txt
@@ -1,4 +1,4 @@
-﻿if($var$ $sign$ null)
+﻿if($temp$ $sign$ null)
 {
     $var$ = $value$;
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Constant.cs b/src/SimpleStateMachine.StructuralSearch/Constant.cs
@@ -4,6 +4,11 @@ namespace SimpleStateMachine.StructuralSearch
 {
     public static class Constant
     {
+        /// <summary>
+        /// Parenthesis empty string
+        /// </summary>
+        public static readonly string Empty = string.Empty;
+        
         /// <summary>
         /// Parenthesis char: '('
         /// </summary>
diff --git a/src/SimpleStateMachine.StructuralSearch/Extensions/EnumerableStringExtensions.cs b/src/SimpleStateMachine.StructuralSearch/Extensions/EnumerableStringExtensions.cs
@@ -9,5 +9,10 @@ public static string JoinToString(this IEnumerable<string> enumerable, string se
         {
             return string.Join(separator, enumerable);
         }
+        
+        public static string JoinToString(this List<string> enumerable, string separator = null)
+        {
+            return string.Join(separator, enumerable);
+        }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Extensions/ParserExtensions.cs b/src/SimpleStateMachine.StructuralSearch/Extensions/ParserExtensions.cs
@@ -16,19 +16,26 @@ namespace SimpleStateMachine.StructuralSearch.Extensions
 {
     public static class ParserExtensions
     {
-        
         public static Parser<TToken, T> Try<TToken, T>(this Parser<TToken, T> parser)
         {
             return Parser.Try(parser);
         }
-        
-        public static Parser<TToken, IEnumerable<T>> AtLeastOnceUntilNot<TToken, T, U>(this Parser<TToken, T> parser, 
+
+
+        public static Parser<TToken, IEnumerable<T>> AsMany<TToken, T>(this Parser<TToken, T> parser)
+        {
+            return parser.Select(x => (IEnumerable<T>)new List<T> { x });
+        }
+
+        public static Parser<TToken, IEnumerable<T>> AtLeastOnceUntilNot<TToken, T, U>(this Parser<TToken, T> parser,
             Parser<TToken, U> terminator)
         {
-            return parser != null ? parser.AtLeastOnceUntil(Not(terminator)) : throw new ArgumentNullException(nameof (parser));
+            return parser != null
+                ? parser.AtLeastOnceUntil(Not(terminator))
+                : throw new ArgumentNullException(nameof(parser));
         }
-        
-        
+
+
         // public static Parser<TToken, TOut> WithResult<TToken, TOut>(this Parser<TToken, TOut> parser, Func<TToken, SourcePos, TOut> transformResult)
         // {
         //     = Parser<TToken>.CurrentSourcePosDelta.Select<SourcePos>((Func<SourcePosDelta, SourcePos>) (d => new SourcePos(1, 1) + d));
@@ -64,7 +71,7 @@ public static Parser<TToken, T> WithDebug<TToken, T>(this Parser<TToken, T> pars
                 return u;
             }, parser, Parser<TToken>.CurrentPos, Parser<TToken>.CurrentSourcePosDelta);
         }
-        
+
         public static Parser<TToken, T> WithDebug<TToken, T>(this Parser<TToken, T> parser)
         {
             return Map((u, t, v) =>
@@ -73,7 +80,7 @@ public static Parser<TToken, T> WithDebug<TToken, T>(this Parser<TToken, T> pars
                 return u;
             }, parser, Parser<TToken>.CurrentPos, Parser<TToken>.CurrentSourcePosDelta);
         }
-        
+
         public static Parser<TToken, T> BetweenAsThen<TToken, T, U, V>(this Parser<TToken, T> parser,
             Parser<TToken, U> parser1,
             Parser<TToken, V> parser2, Func<U, T, V, T> func)
diff --git a/src/SimpleStateMachine.StructuralSearch/Extensions/SourceMatchManyParserExtensions.cs b/src/SimpleStateMachine.StructuralSearch/Extensions/SourceMatchManyParserExtensions.cs
@@ -0,0 +1,20 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using Pidgin;
+
+namespace SimpleStateMachine.StructuralSearch.Extensions
+{
+    public static class SourceMatchParserExtensions
+    {
+        // public static Parser<TToken, Parser<TToken, R>> JoinResults<TToken, T, R>(this Parser<TToken, IEnumerable<Parser<TToken, T>>> parsers)
+        // {
+        //     return parsers.Select(x => Parsers.Series(x, getResult));
+        // }
+        
+        public static Parser<char, Parser<char, SourceMatch>> JoinResults(this Parser<char, IEnumerable<Parser<char, SourceMatch>>> parsers)
+        {
+            return parsers.Select(x => Parsers.Series(x, y => y.Concatenate()));
+        }
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/Extensions/StringParserExtensions.cs b/src/SimpleStateMachine.StructuralSearch/Extensions/StringParserExtensions.cs
@@ -47,6 +47,12 @@ public static Parser<TToken, string> JoinToString<TToken>(this Parser<TToken, IE
             return parser.Select(x => string.Join(separator, x));
         }
         
+        public static Parser<TToken, string> JoinToString<TToken>(this Parser<TToken, List<string>> parser, string separator = null)
+        {
+            separator ??= string.Empty;
+            return parser.Select(x => string.Join(separator, x));
+        }
+        
         public static Parser<TToken, SourceMatch> AsMatch<TToken>(this Parser<TToken, string> parser)
         {
             return parser.Then(Parser<TToken>.CurrentOffset, (s, offset) => new SourceMatch(s, offset - s.Length, offset));
diff --git a/src/SimpleStateMachine.StructuralSearch/ParserToParser.cs b/src/SimpleStateMachine.StructuralSearch/ParserToParser.cs
@@ -1,4 +1,7 @@
-﻿using Pidgin;
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using Pidgin;
 using SimpleStateMachine.StructuralSearch.Extensions;
 using static Pidgin.Parser<char>;
 using static Pidgin.Parser;
@@ -33,5 +36,6 @@ public static Parser<char, Parser<char, SourceMatch>> ResultAsMatch(Parser<char,
         {
             return parser.Select(x=> Parser.String(x).AsMatch());
         }
+
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/LookaheadParser.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/LookaheadParser.cs
@@ -18,7 +18,8 @@ public void Lookahead<Res1, Res2>(Func<Parser<TToken, Res1>> next, Func<Parser<T
         public override bool TryParse(ref ParseState<TToken> state, ref PooledList<Expected<TToken>> expected,
             out T result)
         {
-            return _parser.TryParse(ref state, ref expected, out result);
+            var res = _parser.TryParse(ref state, ref expected, out result);
+            return res;
         }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/Parsers.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/Parsers.cs
@@ -10,48 +10,51 @@ namespace SimpleStateMachine.StructuralSearch
     public static class Parsers
     {
         public static Parser<char, string> Stringc(char character) => String(character.ToString());
-        
-        public static Parser<TToken, List<T>> MapToMany<TToken, T>(Parser<TToken, T> parser1, Parser<TToken, T> parser2, Parser<TToken, T> parser3)
+
+        public static Parser<TToken, IEnumerable<T>> MapToMany<TToken, T>(Parser<TToken, T> parser1,
+            Parser<TToken, 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) => new List<T>{arg1, arg2, arg3}, parser1, parser2, parser2);
+                throw new ArgumentNullException(nameof(parser3));
+
+            return Map((arg1, arg2, arg3) => (IEnumerable<T>)new List<T> { arg1, arg2, arg3 }, parser1, parser2,
+                parser3);
         }
-        
-        public static Parser<TToken, IEnumerable<T>> MapToMany<TToken, T>(Parser<TToken, T> parser1, Parser<TToken, IEnumerable<T>> parser2, Parser<TToken, T> parser3)
+
+        public static Parser<TToken, IEnumerable<T>> MapToMany<TToken, T>(Parser<TToken, T> parser1,
+            Parser<TToken, IEnumerable<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));
-            
+                throw new ArgumentNullException(nameof(parser3));
+
             return Map((arg1, arg2, arg3) =>
             {
                 var result = arg2.ToList();
                 result.Insert(0, arg1);
                 result.Add(arg3);
-                return result as IEnumerable<T>;
+                return (IEnumerable<T>)result;
             }, parser1, parser2, parser3);
         }
-        
-        public static Parser<TToken, R> Series<TToken, T, R>(IEnumerable<Parser<TToken, T>> parsers, 
+
+        public static Parser<TToken, R> Series<TToken, T, R>(IEnumerable<Parser<TToken, T>> parsers,
             Func<IEnumerable<T>, R> func)
         {
             if (parsers == null)
-                throw new ArgumentNullException(nameof (parsers));
+                throw new ArgumentNullException(nameof(parsers));
             if (func == null)
-                throw new ArgumentNullException(nameof (func));
+                throw new ArgumentNullException(nameof(func));
 
             return new SeriesParser<TToken, T, R>(parsers, func);
         }
-        
+
         public static Parser<char, IEnumerable<T>> BetweenChars<T>(char left, char right,
             Func<char, Parser<char, T>> leftRight,
             Parser<char, IEnumerable<T>> expr)
@@ -65,5 +68,13 @@ public static Parser<char, IEnumerable<T>> BetweenOneOfChars<T>(Func<char, Parse
                 MapToMany(leftRight(x.Item1), expr, leftRight(x.Item2)))
             );
         }
+
+        public static Parser<char, IEnumerable<T>> BetweenOneOfChars<T>(Func<char, Parser<char, T>> leftRight,
+            Parser<char, T> expr, params (char, char)[] values)
+        {
+            return OneOf(values.Select(x =>
+                MapToMany(leftRight(x.Item1), expr, leftRight(x.Item2)))
+            );
+        }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs
@@ -6,35 +6,71 @@
 
 namespace SimpleStateMachine.StructuralSearch
 {
-    public class PlaceholderParser: LookaheadParser<char, SourceMatch>
+    public class PlaceholderParser : LookaheadParser<char, SourceMatch>
     {
         public string Name { get; }
-        
+
         public PlaceholderParser(string name)
         {
             Name = name;
         }
-
-        public override Parser<char, SourceMatch> BuildParser<Res1, Res2>(Func<Parser<char, Res1>> next, Func<Parser<char, Res2>> nextNext)
+        
+        public override Parser<char, SourceMatch> BuildParser<Res1, Res2>(Func<Parser<char, Res1>> next,
+            Func<Parser<char, Res2>> nextNext)
         {
             var _next = next();
             var _nextNext = nextNext();
             var lookahead = Parser.Lookahead(_next.Then(_nextNext).Try());
-            var anyString = Parser<char>.Any.AtLeastOnceAsStringUntil(lookahead)
-                .Try();
+            var anyString = CommonTemplateParser.AnyCharWithPlshd
+                .AtLeastOnceAsStringUntil(lookahead);
             
-            var simpleString = CommonTemplateParser.StringWithoutParenthesisedAndWhiteSpaces;
-            var token = Parser.OneOf(simpleString, CommonParser.WhiteSpaces)
-                .AtLeastOnce();
-            Parser<char, IEnumerable<string>> term = null;
+            var simpleString = CommonTemplateParser.StringWithPlshd.Labelled("simpleString");
+            var token = Parser.OneOf(simpleString, CommonParser.WhiteSpaces).Try();
+            Parser<char, string> term = null;
+
+            var parenthesised = Parsers.BetweenOneOfChars(Parsers.Stringc,
+                expr: Parser.Rec(() => term),
+                Constant.AllParenthesised).JoinToString();
+            
+            term = Parser.OneOf(parenthesised, token).Many().JoinToString();
             
-            var parenthesised = Parsers.BetweenOneOfChars(Parsers.Stringc, 
-                Parser.Rec(() => term), 
-                Constant.AllParenthesised);
+            //parenthesised and tokens and whiteSpaces
+            var prdsAndTokens = Parser.OneOf(parenthesised, token)
+                .Until(lookahead)
+                .JoinToString()
+                .Try();
             
-            term = Parser.OneOf(token, parenthesised).AtLeastOnce().MergerMany();
-            var parser = Parser.OneOf(parenthesised.JoinToString(), anyString).AsMatch();
+            var parser = prdsAndTokens.Or(anyString).AsMatch();
             return parser;
         }
+
+
+        // internal Parser<char, SourceMatch> GetParser()
+        // {
+        //     
+        // }
+        // public override Parser<char, SourceMatch> BuildParser<Res1, Res2>(Func<Parser<char, Res1>> next, Func<Parser<char, Res2>> nextNext)
+        // {
+        //     var _next = next();
+        //     var _nextNext = nextNext();
+        //     var lookahead = Parser.Lookahead(_next.Then(_nextNext).Try());
+        //     var anyString = Parser<char>.Any.AtLeastOnceAsStringUntil(lookahead)
+        //         .Try();
+        //     
+        //     var simpleString = CommonTemplateParser.StringWithoutParenthesisedAndWhiteSpaces;
+        //     var token = Parser.OneOf(simpleString, CommonParser.WhiteSpaces)
+        //         .AtLeastOnce();
+        //     Parser<char, IEnumerable<string>> term = null;
+        //     
+        //     var parenthesised = Parsers.BetweenOneOfChars(Parsers.Stringc, 
+        //         Parser.Rec(() => term), 
+        //         Constant.AllParenthesised);
+        //     
+        //     term = Parser.OneOf(token, parenthesised).AtLeastOnce().MergerMany();
+        //
+        //     // var parser = Parser.OneOf(term.JoinToString(), anyString).AsMatch();
+        //     var parser = term.JoinToString().AsMatch();
+        //     return parser;
+        // }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/SeriesParser.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/SeriesParser.cs
@@ -21,7 +21,7 @@ public override bool TryParse(ref ParseState<TToken> state, ref PooledList<Expec
             var results = new List<T>();
             var count = parsers.Count();
             
-            for (var i = count - 1; i > 0 ; i--)
+            for (var i = count-1; i >= 0 ; i--)
             {
                 if (parsers.ElementAt(i) is LookaheadParser<TToken, T> lookaheadParser)
                 {
diff --git a/src/SimpleStateMachine.StructuralSearch/SourceMatch.cs b/src/SimpleStateMachine.StructuralSearch/SourceMatch.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/CommonParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/CommonParser.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/CommonTemplateParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/CommonTemplateParser.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindTemplateParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindTemplateParser.cs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`	`1`	`if(temp == null)`
`2`	`2`	`{`
`3`		`- temp = new List<string>();`
	`3`	`+ temp = 12;`
`4`	`4`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-((value1) && (value2))`
	`1`	`+(((value1) && (value2)) && (value1) && (value2))`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-if($var$ $sign$ null)`
	`1`	`+if($temp$ $sign$ null)`
`2`	`2`	`{`
`3`	`3`	`$var$ = $value$;`
`4`	`4`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,11 @@ namespace SimpleStateMachine.StructuralSearch`
`4`	`4`	`{`
`5`	`5`	`public static class Constant`
`6`	`6`	`{`
	`7`	`+ /// <summary>`
	`8`	`+ /// Parenthesis empty string`
	`9`	`+ /// </summary>`
	`10`	`+ public static readonly string Empty = string.Empty;`
	`11`	`+`
`7`	`12`	`/// <summary>`
`8`	`13`	`/// Parenthesis char: '('`
`9`	`14`	`/// </summary>`
Original file line number	Diff line number	Diff line change
`@@ -9,5 +9,10 @@ public static string JoinToString(this IEnumerable<string> enumerable, string se`
`9`	`9`	`{`
`10`	`10`	`return string.Join(separator, enumerable);`
`11`	`11`	`}`
	`12`	`+`
	`13`	`+ public static string JoinToString(this List<string> enumerable, string separator = null)`
	`14`	`+ {`
	`15`	`+ return string.Join(separator, enumerable);`
	`16`	`+ }`
`12`	`17`	`}`
`13`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,19 +16,26 @@ namespace SimpleStateMachine.StructuralSearch.Extensions`
`16`	`16`	`{`
`17`	`17`	`public static class ParserExtensions`
`18`	`18`	`{`
`19`		`-`
`20`	`19`	`public static Parser<TToken, T> Try<TToken, T>(this Parser<TToken, T> parser)`
`21`	`20`	`{`
`22`	`21`	`return Parser.Try(parser);`
`23`	`22`	`}`
`24`		`-`
`25`		`- public static Parser<TToken, IEnumerable<T>> AtLeastOnceUntilNot<TToken, T, U>(this Parser<TToken, T> parser,`
	`23`	`+`
	`24`	`+`
	`25`	`+ public static Parser<TToken, IEnumerable<T>> AsMany<TToken, T>(this Parser<TToken, T> parser)`
	`26`	`+ {`
	`27`	`+ return parser.Select(x => (IEnumerable<T>)new List<T> { x });`
	`28`	`+ }`
	`29`	`+`
	`30`	`+ public static Parser<TToken, IEnumerable<T>> AtLeastOnceUntilNot<TToken, T, U>(this Parser<TToken, T> parser,`
`26`	`31`	`Parser<TToken, U> terminator)`
`27`	`32`	`{`
`28`		`- return parser != null ? parser.AtLeastOnceUntil(Not(terminator)) : throw new ArgumentNullException(nameof (parser));`
	`33`	`+ return parser != null`
	`34`	`+ ? parser.AtLeastOnceUntil(Not(terminator))`
	`35`	`+ : throw new ArgumentNullException(nameof(parser));`
`29`	`36`	`}`
`30`		`-`
`31`		`-`
	`37`	`+`
	`38`	`+`
`32`	`39`	`// public static Parser<TToken, TOut> WithResult<TToken, TOut>(this Parser<TToken, TOut> parser, Func<TToken, SourcePos, TOut> transformResult)`
`33`	`40`	`// {`
`34`	`41`	`// = Parser<TToken>.CurrentSourcePosDelta.Select<SourcePos>((Func<SourcePosDelta, SourcePos>) (d => new SourcePos(1, 1) + d));`
`@@ -64,7 +71,7 @@ public static Parser<TToken, T> WithDebug<TToken, T>(this Parser<TToken, T> pars`
`64`	`71`	`return u;`
`65`	`72`	`}, parser, Parser<TToken>.CurrentPos, Parser<TToken>.CurrentSourcePosDelta);`
`66`	`73`	`}`
`67`		`-`
	`74`	`+`
`68`	`75`	`public static Parser<TToken, T> WithDebug<TToken, T>(this Parser<TToken, T> parser)`
`69`	`76`	`{`
`70`	`77`	`return Map((u, t, v) =>`
`@@ -73,7 +80,7 @@ public static Parser<TToken, T> WithDebug<TToken, T>(this Parser<TToken, T> pars`
`73`	`80`	`return u;`
`74`	`81`	`}, parser, Parser<TToken>.CurrentPos, Parser<TToken>.CurrentSourcePosDelta);`
`75`	`82`	`}`
`76`		`-`
	`83`	`+`
`77`	`84`	`public static Parser<TToken, T> BetweenAsThen<TToken, T, U, V>(this Parser<TToken, T> parser,`
`78`	`85`	`Parser<TToken, U> parser1,`
`79`	`86`	`Parser<TToken, V> parser2, Func<U, T, V, T> func)`