Merge pull request #93 from datalust/dev

2.3.0 Release

Author: nblumhardt

Superpower.sln.DotSettings

@@ -1,2 +1,12 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
-	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=TypeParameters/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="T" Suffix="" Style="AaBb"&gt;&lt;ExtraRule Prefix="" Suffix="" Style="AA_BB" /&gt;&lt;/Policy&gt;</s:String></wpf:ResourceDictionary>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=TypeParameters/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="T" Suffix="" Style="AaBb"&gt;&lt;ExtraRule Prefix="" Suffix="" Style="AA_BB" /&gt;&lt;/Policy&gt;</s:String>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=allocs/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=errloc/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=frac/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=lparen/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Numerics/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=opvalue/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=rparen/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Sprache/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=tokenized/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=tokenizers/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

sample/JsonParser/Program.cs

@@ -62,7 +62,7 @@ enum JsonToken
         // concept that groups `true`, `false`, and `null`, it's useful
         // for the tokenizer to be very permissive - it's more informative
         // to generate an error later at the parsing stage, e.g.
-        // "unexpected identifier `flase`", instead of failing at the
+        // "unexpected identifier `false`", instead of failing at the
         // tokenization stage where all we'd have is "unexpected `l`".
         Identifier,
     }
@@ -100,7 +100,6 @@ static class JsonTokenizer
         static TextParser<Unit> JsonStringToken { get; } =
             from open in Character.EqualTo('"')
             from content in Span.EqualTo("\\\"").Value(Unit.Value).Try()
-                .Or(Span.EqualTo("\\\\").Value(Unit.Value).Try())
                 .Or(Character.Except('"').Value(Unit.Value))
                 .IgnoreMany()
             from close in Character.EqualTo('"')

src/Superpower/Combinators.cs

@@ -395,19 +395,19 @@ public static TokenListParser<TKind, T[]> Many<TKind, T>(this TokenListParser<TK
             return input =>
             {
                 var result = new List<T>();
-                var @from = input;
+                var from = input;
                 var r = parser(input);
                 while (r.HasValue)
                 {
-                    if (@from == r.Remainder) // Broken parser, not a failed parsing.
-                        throw new ParseException($"Many() cannot be applied to zero-width parsers; value {r.Value} at position {r.Location.Position}.");
+                    if (from == r.Remainder) // Broken parser, not a failed parsing.
+                        throw new ParseException($"Many() cannot be applied to zero-width parsers; value {r.Value} at position {r.Location.Position}.", r.ErrorPosition);
 
                     result.Add(r.Value);
-                    @from = r.Remainder;
+                    from = r.Remainder;
                     r = parser(r.Remainder);
                 }
 
-                if (!r.Backtrack && r.IsPartial(@from))
+                if (!r.Backtrack && r.IsPartial(from))
                     return TokenListParserResult.CastEmpty<TKind, T, T[]>(r);
 
                 return TokenListParserResult.Value(result.ToArray(), input, from);
@@ -433,7 +433,7 @@ public static TextParser<T[]> Many<T>(this TextParser<T> parser)
                 while (r.HasValue)
                 {
                     if (from == r.Remainder) // Broken parser, not a failed parsing.
-                        throw new ParseException($"Many() cannot be applied to zero-width parsers; value {r.Value} at position {r.Location.Position}.");
+                        throw new ParseException($"Many() cannot be applied to zero-width parsers; value {r.Value} at position {r.Location.Position}.", r.Location.Position);
 
                     result.Add(r.Value);
 
@@ -467,7 +467,7 @@ public static TextParser<Unit> IgnoreMany<T>(this TextParser<T> parser)
                 while (r.HasValue)
                 {
                     if (from == r.Remainder) // Broken parser, not a failed parsing.
-                        throw new ParseException($"IgnoreMany() cannot be applied to zero-width parsers; value {r.Value} at position {r.Location.Position}.");
+                        throw new ParseException($"IgnoreMany() cannot be applied to zero-width parsers; value {r.Value} at position {r.Location.Position}.", r.Location.Position);
 
                     from = r.Remainder;
                     r = parser(r.Remainder);
@@ -499,6 +499,8 @@ public static TokenListParser<TKind, T[]> ManyDelimitedBy<TKind, T, U>(
             if (parser == null) throw new ArgumentNullException(nameof(parser));
             if (delimiter == null) throw new ArgumentNullException(nameof(delimiter));
 
+            // ReSharper disable once ConvertClosureToMethodGroup
+
             if (end != null)
                 return parser
                     .AtLeastOnceDelimitedBy(delimiter)
@@ -655,7 +657,7 @@ public static TextParser<T> Named<T>(this TextParser<T> parser, string name)
         /// <param name="parser">The parser.</param>
         /// <param name="defaultValue">The default value</param>
         /// <returns>The resulting parser.</returns>
-        public static TokenListParser<TKind, T> OptionalOrDefault<TKind, T>(this TokenListParser<TKind, T> parser, T defaultValue = default(T))
+        public static TokenListParser<TKind, T> OptionalOrDefault<TKind, T>(this TokenListParser<TKind, T> parser, T defaultValue = default)
         {
             if (parser == null) throw new ArgumentNullException(nameof(parser));
 
@@ -670,7 +672,7 @@ public static TextParser<T> Named<T>(this TextParser<T> parser, string name)
         /// <param name="parser">The parser.</param>
         /// <param name="defaultValue">The default value.</param>
         /// <returns>The resulting parser.</returns>
-        public static TextParser<T> OptionalOrDefault<T>(this TextParser<T> parser, T defaultValue = default(T))
+        public static TextParser<T> OptionalOrDefault<T>(this TextParser<T> parser, T defaultValue = default)
         {
             if (parser == null) throw new ArgumentNullException(nameof(parser));
 
@@ -746,7 +748,16 @@ public static TokenListParser<TKind, U> Select<TKind, T, U>(this TokenListParser
             if (parser == null) throw new ArgumentNullException(nameof(parser));
             if (selector == null) throw new ArgumentNullException(nameof(selector));
 
-            return parser.Then(rt => Parse.Return<TKind, U>(selector(rt)));
+            return input =>
+            {
+                var rt = parser(input);
+                if (!rt.HasValue)
+                    return TokenListParserResult.CastEmpty<TKind, T, U>(rt);
+
+                var u = selector(rt.Value);
+
+                return TokenListParserResult.Value(u, input, rt.Remainder);
+            };
         }
 
         /// <summary>
@@ -762,7 +773,16 @@ public static TextParser<U> Select<T, U>(this TextParser<T> parser, Func<T, U> s
             if (parser == null) throw new ArgumentNullException(nameof(parser));
             if (selector == null) throw new ArgumentNullException(nameof(selector));
 
-            return parser.Then(rt => Parse.Return(selector(rt)));
+            return input =>
+            {
+                var rt = parser(input);
+                if (!rt.HasValue)
+                    return Result.CastEmpty<T, U>(rt);
+
+                var u = selector(rt.Value);
+
+                return Result.Value(u, input, rt.Remainder);
+            };
         }
 
         /// <summary>
@@ -778,7 +798,7 @@ public static TokenListParser<TKind, U> Cast<TKind, T, U>(this TokenListParser<T
         {
             if (parser == null) throw new ArgumentNullException(nameof(parser));
 
-            return parser.Then(rt => Parse.Return<TKind, U>((U)rt));
+            return parser.Select(rt => (U)rt);
         }
 
         /// <summary>
@@ -793,7 +813,7 @@ public static TextParser<U> Cast<T, U>(this TextParser<T> parser)
         {
             if (parser == null) throw new ArgumentNullException(nameof(parser));
 
-            return parser.Then(rt => Parse.Return((U)rt));
+            return parser.Select(rt => (U)rt);
         }
 
         /// <summary>
@@ -1023,6 +1043,113 @@ public static TextParser<T> Where<T>(this TextParser<T> parser, Func<T, bool> pr
 
                 return Result.Empty<T>(input, "unsatisfied condition");
             };
+        } 
+        
+        /// <summary>
+        /// Parse a sequence of operands connected by left-associative operators.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the leftmost operand and of the ultimate result.</typeparam>
+        /// <typeparam name="TOperator">The type of the operator.</typeparam>
+        /// <typeparam name="TOperand">The type of subsequent operands.</typeparam>
+        /// <param name="parser">The parser for the leftmost operand.</param>
+        /// <param name="operator">A parser matching operators.</param>
+        /// <param name="operand">A parser matching operands.</param>
+        /// <param name="apply">A function combining the operator, left operand, and right operand, into the result.</param>
+        /// <returns>The result of calling <paramref name="apply"/> successively on pairs of operands.</returns>
+        public static TextParser<TResult> Chain<TResult, TOperator, TOperand>(
+            this TextParser<TResult> parser,
+            TextParser<TOperator> @operator,
+            TextParser<TOperand> operand,
+            Func<TOperator, TResult, TOperand, TResult> apply)
+        {
+            if (parser == null) throw new ArgumentNullException(nameof(parser));
+            if (@operator == null) throw new ArgumentNullException(nameof(@operator));
+            if (operand == null) throw new ArgumentNullException(nameof(operand));
+            if (apply == null) throw new ArgumentNullException(nameof(apply));
+
+            return input =>
+            {
+                var parseResult = parser(input);
+                if (!parseResult.HasValue)
+                    return parseResult;
+
+                var result = parseResult.Value;
+                var operandRemainder = parseResult.Remainder;
+
+                var operatorResult = @operator(operandRemainder);
+                while (operatorResult.HasValue || operatorResult.IsPartial(operandRemainder))
+                {
+                    // If operator read any input, but failed to read complete input, we return error
+                    if (!operatorResult.HasValue)
+                        return Result.CastEmpty<TOperator, TResult>(operatorResult);
+
+                    var operandResult = operand(operatorResult.Remainder);
+                    operandRemainder = operandResult.Remainder;
+
+                    if (!operandResult.HasValue)
+                        return Result.CastEmpty<TOperand, TResult>(operandResult);
+
+                    result = apply(operatorResult.Value, result, operandResult.Value);
+
+                    operatorResult = @operator(operandRemainder);
+                }
+
+                return Result.Value(result, input, operandRemainder);
+            };
+        }
+
+        /// <summary>
+        /// Parse a sequence of operands connected by left-associative operators.
+        /// </summary>
+        /// <typeparam name="TKind">The kind of the tokens being parsed.</typeparam>
+        /// <typeparam name="TResult">The type of the leftmost operand and of the ultimate result.</typeparam>
+        /// <typeparam name="TOperator">The type of the operator.</typeparam>
+        /// <typeparam name="TOperand">The type of subsequent operands.</typeparam>
+        /// <param name="parser">The parser for the leftmost operand.</param>
+        /// <param name="operator">A parser matching operators.</param>
+        /// <param name="operand">A parser matching operands.</param>
+        /// <param name="apply">A function combining the operator, left operand, and right operand, into the result.</param>
+        /// <returns>The result of calling <paramref name="apply"/> successively on pairs of operands.</returns>
+        public static TokenListParser<TKind, TResult> Chain<TKind, TResult, TOperator, TOperand>(
+            this TokenListParser<TKind, TResult> parser,
+            TokenListParser<TKind, TOperator> @operator,
+            TokenListParser<TKind, TOperand> operand,
+            Func<TOperator, TResult, TOperand, TResult> apply)
+        {
+            if (parser == null) throw new ArgumentNullException(nameof(parser));
+            if (@operator == null) throw new ArgumentNullException(nameof(@operator));
+            if (operand == null) throw new ArgumentNullException(nameof(operand));
+            if (apply == null) throw new ArgumentNullException(nameof(apply));
+
+            return input =>
+            {
+                var parseResult = parser(input);
+                if (!parseResult.HasValue )
+                    return parseResult;
+
+                var result = parseResult.Value;
+                var operandRemainder = parseResult.Remainder;
+
+                var operatorResult = @operator(operandRemainder);
+                while (operatorResult.HasValue || operatorResult.IsPartial(operandRemainder))
+                {
+                    // If operator read any input, but failed to read complete input, we return error
+                    if (!operatorResult.HasValue) 
+                        return TokenListParserResult.CastEmpty<TKind, TOperator, TResult>(operatorResult);
+
+                    var operandResult = operand(operatorResult.Remainder);
+                    operandRemainder = operandResult.Remainder;
+
+                    if (!operandResult.HasValue)
+                        return TokenListParserResult.CastEmpty<TKind, TOperand, TResult>(operandResult);
+
+                    result = apply(operatorResult.Value, result, operandResult.Value);
+
+                    operatorResult = @operator(operandRemainder);
+                }
+
+                return TokenListParserResult.Value(result, input, operandRemainder);
+            };
         }
     }
 }

src/Superpower/Model/Position.cs

@@ -62,7 +62,7 @@ public Position(int absolute, int line, int column)
         /// <summary>
         /// A position with no value.
         /// </summary>
-        public static Position Empty { get; } = default(Position);
+        public static Position Empty { get; } = default;
 
         /// <summary>
         /// True if the position has a value.

src/Superpower/Model/Result`1.cs

@@ -88,7 +88,7 @@ internal Result(TextSpan location, TextSpan remainder, string errorMessage, stri
         {
             Location = location;
             Remainder = remainder;
-            _value = default(T);
+            _value = default;
             HasValue = false;
             Expectations = expectations;
             ErrorMessage = errorMessage;
@@ -98,7 +98,7 @@ internal Result(TextSpan location, TextSpan remainder, string errorMessage, stri
         internal Result(TextSpan remainder, string errorMessage, string[] expectations, bool backtrack)
         {
             Location = Remainder = remainder;
-            _value = default(T);
+            _value = default;
             HasValue = false;
             Expectations = expectations;
             ErrorMessage = errorMessage;

src/Superpower/Model/TextSpan.cs

@@ -69,7 +69,7 @@ public TextSpan(string source, Position position, int length)
         /// <summary>
         /// A span with no value.
         /// </summary>
-        public static TextSpan None { get; } = default(TextSpan);
+        public static TextSpan None { get; } = default;
 
         /// <summary>
         /// A span corresponding to the empty string.

src/Superpower/Model/TokenListParserResult`2.cs

@@ -111,7 +111,7 @@ internal TokenListParserResult(TokenList<TKind> location, TokenList<TKind> remai
         {
             Location = location;
             Remainder = remainder;
-            _value = default(T);
+            _value = default;
             HasValue = false;
             SubTokenErrorPosition = errorPosition;
             ErrorMessage = errorMessage;
@@ -122,7 +122,7 @@ internal TokenListParserResult(TokenList<TKind> location, TokenList<TKind> remai
         internal TokenListParserResult(TokenList<TKind> remainder, Position errorPosition, string errorMessage, string[] expectations, bool backtrack)
         {
             Location = Remainder = remainder;
-            _value = default(T);
+            _value = default;
             HasValue = false;
             SubTokenErrorPosition = errorPosition;
             ErrorMessage = errorMessage;

src/Superpower/Model/TokenList`1.cs

@@ -55,7 +55,7 @@ public TokenList(Token<TKind>[] tokens)
         /// <summary>
         /// A token list with no value.
         /// </summary>
-        public static TokenList<TKind> Empty { get; } = default(TokenList<TKind>);
+        public static TokenList<TKind> Empty { get; } = default;
 
         /// <summary>
         /// True if the token list contains no tokens.

src/Superpower/Model/Token`1.cs

@@ -60,7 +60,7 @@ public Token(TKind kind, TextSpan span)
         /// <summary>
         /// A token with no value.
         /// </summary>
-        public static Token<TKind> Empty { get; } = default(Token<TKind>);
+        public static Token<TKind> Empty { get; } = default;
 
         /// <inheritdoc/>
         public override string ToString()

src/Superpower/Model/Unit.cs

@@ -22,6 +22,6 @@ public struct Unit
         /// <summary>
         /// The singleton value of the struct, with no value.
         /// </summary>
-        public static Unit Value { get; } = default(Unit);
+        public static Unit Value { get; } = default;
     }
 }