body to expression

src/SimpleStateMachine.StructuralSearch/Configurations/Configuration.cs

@@ -20,14 +20,10 @@ public bool Equals(Configuration? other)
             return findTemplateEquals && findRulesEquals && replaceTemplateEquals && replaceRulesEquals;
         }
 
-        public override bool Equals(object? obj)
-        {
-            return obj?.GetType() == GetType() && Equals((Configuration)obj);
-        }
+        public override bool Equals(object? obj) 
+            => obj?.GetType() == GetType() && Equals((Configuration)obj);
 
-        public override int GetHashCode()
-        {
-            return HashCode.Combine(FindTemplate, FindRules, ReplaceTemplate, ReplaceRules);
-        }
+        public override int GetHashCode() 
+            => HashCode.Combine(FindTemplate, FindRules, ReplaceTemplate, ReplaceRules);
     }
 }

src/SimpleStateMachine.StructuralSearch/Configurations/ConfigurationFile.cs

@@ -19,19 +19,13 @@ public ConfigurationFile(List<Configuration> configurations)
 
         public List<Configuration> Configurations { get; init; }
 
-        public bool Equals(ConfigurationFile? other)
-        {
-            return other?.Configurations != null && Configurations.SequenceEqual(other.Configurations);
-        }
+        public bool Equals(ConfigurationFile? other) 
+            => other?.Configurations != null && Configurations.SequenceEqual(other.Configurations);
 
-        public override bool Equals(object? obj)
-        {
-            return obj?.GetType() == GetType() && Equals((ConfigurationFile)obj);
-        }
+        public override bool Equals(object? obj) 
+            => obj?.GetType() == GetType() && Equals((ConfigurationFile)obj);
 
-        public override int GetHashCode()
-        {
-            return Configurations.GetHashCode();
-        }
+        public override int GetHashCode() 
+            => Configurations.GetHashCode();
     }
 }

src/SimpleStateMachine.StructuralSearch/EmptyParsingContext.cs

@@ -12,33 +12,21 @@ public EmptyParsingContext(IInput input)
         }
 
         public bool TryGetPlaceholder(string name, out IPlaceholder value)
-        {
-            throw new System.NotImplementedException();
-        }
+            => throw new System.NotImplementedException();
 
-        public void AddPlaceholder(IPlaceholder placeholder)
-        {
-            throw new System.NotImplementedException();
-        }
+        public void AddPlaceholder(IPlaceholder placeholder) 
+            => throw new System.NotImplementedException();
 
-        public IPlaceholder GetPlaceholder(string name)
-        {
-            return Placeholder.CreateEmpty(this, name, string.Empty);
-        }
+        public IPlaceholder GetPlaceholder(string name) 
+            => Placeholder.CreateEmpty(this, name, string.Empty);
 
-        public IReadOnlyDictionary<string, IPlaceholder> SwitchOnNew()
-        {
-            throw new System.NotImplementedException();
-        }
+        public IReadOnlyDictionary<string, IPlaceholder> SwitchOnNew() 
+            => throw new System.NotImplementedException();
 
-        public void Fill(IReadOnlyDictionary<string, IPlaceholder> placeholders)
-        {
-            throw new System.NotImplementedException();
-        }
+        public void Fill(IReadOnlyDictionary<string, IPlaceholder> placeholders) 
+            => throw new System.NotImplementedException();
 
         public IReadOnlyDictionary<string, IPlaceholder> Clear()
-        {
-            throw new System.NotImplementedException();
-        }
+            => throw new System.NotImplementedException();
     }
 }

src/SimpleStateMachine.StructuralSearch/Extensions/CharParserExtensions.cs

@@ -5,21 +5,13 @@ namespace SimpleStateMachine.StructuralSearch.Extensions
 {
     public static class CharParserExtensions
     {
-        public static Parser<TToken, string> AsString<TToken>(this Parser<TToken, char> parser)
-        {
-            return parser.Select(x => x.ToString());
-        }
-
-        public static Parser<TToken, string> AtLeastOnceAsStringUntil<TToken, U>(
-            this Parser<TToken, char> parser, Parser<TToken, U> terminator)
-        {
-            return parser != null ? parser.AtLeastOnceUntil(terminator).AsString() : throw new ArgumentNullException(nameof (parser));
-        }
-
-        public static Parser<TToken, string> AtLeastOnceAsStringUntilNot<TToken, U>(this Parser<TToken, char> parser,
-            Parser<TToken, U> terminator)
-        {
-            return parser != null ? parser.AtLeastOnceUntilNot(terminator).AsString() : throw new ArgumentNullException(nameof (parser));
-        }
+        public static Parser<TToken, string> AsString<TToken>(this Parser<TToken, char> parser) 
+            => parser.Select(x => x.ToString());
+
+        public static Parser<TToken, string> AtLeastOnceAsStringUntil<TToken, U>(this Parser<TToken, char> parser, Parser<TToken, U> terminator) 
+            => parser != null ? parser.AtLeastOnceUntil(terminator).AsString() : throw new ArgumentNullException(nameof (parser));
+
+        public static Parser<TToken, string> AtLeastOnceAsStringUntilNot<TToken, U>(this Parser<TToken, char> parser, Parser<TToken, U> terminator) 
+            => parser != null ? parser.AtLeastOnceUntilNot(terminator).AsString() : throw new ArgumentNullException(nameof (parser));
     }
 }

src/SimpleStateMachine.StructuralSearch/Extensions/EnumerableCharExtensions.cs

@@ -6,21 +6,13 @@ namespace SimpleStateMachine.StructuralSearch.Extensions
 {
     public static class EnumerableCharExtensions
     {
-        public static Parser<TToken, string> AsString<TToken>(this Parser<TToken, IEnumerable<char>> parser)
-        {
-            return parser.Select(x => new string(x.ToArray()));
-        }
+        public static Parser<TToken, string> AsString<TToken>(this Parser<TToken, IEnumerable<char>> parser) 
+            => 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));
-        }
+        public static Parser<TToken, IEnumerable<T>> MergerMany<TToken, T>(this Parser<TToken, IEnumerable<IEnumerable<T>>> parser) 
+            => parser.Select(x => x.SelectMany(y => y));
+
+        public static Parser<TToken, IEnumerable<T>> MergerMany<TToken, T>(this Parser<TToken, IEnumerable<List<T>>> parser) 
+            => parser.Select(x => x.SelectMany(y => y));
     }
 }

src/SimpleStateMachine.StructuralSearch/Extensions/IEnumerableExtensions.cs

@@ -5,9 +5,7 @@ namespace SimpleStateMachine.StructuralSearch.Extensions
 {
     public static class IEnumerableExtensions
     {
-        public static IEnumerable<T> EmptyIfNull<T>(this IEnumerable<T>? enumerable)
-        {
-            return enumerable ?? Enumerable.Empty<T>();
-        }
+        public static IEnumerable<T> EmptyIfNull<T>(this IEnumerable<T>? enumerable) 
+            => enumerable ?? Enumerable.Empty<T>();
     }
 }

src/SimpleStateMachine.StructuralSearch/Extensions/ManyParserExtensions.cs

@@ -5,9 +5,7 @@ namespace SimpleStateMachine.StructuralSearch.Extensions
 {
     public static class ManyParserExtensions
     {
-        public static Parser<TToken, IEnumerable<T>> ToIEnumerable<TToken, T>(this Parser<TToken, List<T>> parser)
-        {
-            return parser.As<TToken, List<T>, IEnumerable<T>>();
-        }
+        public static Parser<TToken, IEnumerable<T>> ToIEnumerable<TToken, T>(this Parser<TToken, List<T>> parser) 
+            => parser.As<TToken, List<T>, IEnumerable<T>>();
     }
 }

src/SimpleStateMachine.StructuralSearch/Extensions/ParserExtensions.cs

@@ -7,32 +7,22 @@ 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>> AsMany<TToken, T>(this Parser<TToken, T> parser)
-        {
-            return parser.Select(x => (IEnumerable<T>)new List<T> { x });
-        }
+        public static Parser<TToken, T> Try<TToken, T>(this Parser<TToken, T> parser) 
+            => Parser.Try(parser);
 
-        public static Parser<TToken, IEnumerable<T>> AtLeastOnceUntilNot<TToken, T, U>(this Parser<TToken, T> parser,
-            Parser<TToken, U> terminator)
-        {
-            return parser != null
+        public static Parser<TToken, IEnumerable<T>> AsMany<TToken, T>(this Parser<TToken, T> parser) 
+            => 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) =>
+            parser != null
                 ? parser.AtLeastOnceUntil(Not(terminator))
                 : throw new ArgumentNullException(nameof(parser));
-        }
-
-        public static Parser<TToken, IEnumerable<T>> UntilNot<TToken, T, U>(this Parser<TToken, T> parser,
-            Parser<TToken, U> terminator)
-        {
-            return parser != null
+
+        public static Parser<TToken, IEnumerable<T>> UntilNot<TToken, T, U>(this Parser<TToken, T> parser, Parser<TToken, U> terminator) =>
+            parser != null
                 ? parser.Until(Not(terminator))
                 : throw new ArgumentNullException(nameof(parser));
-        }
-
+
         public static bool TryParse(this Parser<char, string> parser, string value, out string? result)
         {
             if (parser is null)
@@ -43,25 +33,20 @@ public static bool TryParse(this Parser<char, string> parser, string value, out
             return res.Success;
         }
 
-        public static Parser<TToken, T> ThenInvoke<TToken, T>(this Parser<TToken, T> parser, Action<T> action)
-        {
-            return parser.Select(x =>
+        public static Parser<TToken, T> ThenInvoke<TToken, T>(this Parser<TToken, T> parser, Action<T> action) 
+            => parser.Select(x =>
             {
                 action.Invoke(x);
                 return x;
             });
-        }
-
-        public static Parser<TToken, bool> Contains<TToken, T>(this Parser<TToken, T> parser)
-        {
-            return parser != null
+
+        public static Parser<TToken, bool> Contains<TToken, T>(this Parser<TToken, T> parser) 
+            => parser != null
                 ? parser.Optional().Select(x => x.HasValue)
                 : throw new ArgumentNullException(nameof(parser));
-        }
-
-        public static Parser<char, Match<T>> Match<T>(this Parser<char, T> parser)
-        {
-            return Map((oldPos, oldOffset, result, newPos, newOffset) =>
+
+        public static Parser<char, Match<T>> Match<T>(this Parser<char, T> parser) 
+            => Map((oldPos, oldOffset, result, newPos, newOffset) =>
                 {
                     var line = new LinePosition(oldPos.Line, newPos.Line);
                     var column = new ColumnPosition(oldPos.Col, newPos.Col);
@@ -72,16 +57,13 @@ public static Parser<char, Match<T>> Match<T>(this Parser<char, T> parser)
                 Parser<char>.CurrentPos, Parser<char>.CurrentOffset,
                 parser,
                 Parser<char>.CurrentPos, Parser<char>.CurrentOffset);
-        }
 
-        public static Parser<TToken, T> WithDebug<TToken, T>(this Parser<TToken, T> parser, string label)
-        {
-            return Map((u, t, v) =>
+        public static Parser<TToken, T> WithDebug<TToken, T>(this Parser<TToken, T> parser, string label) 
+            => Map((u, t, v) =>
             {
                 Console.WriteLine($"{label} ({t.Col}) : {u} ");
                 return u;
             }, parser, Parser<TToken>.CurrentPos, Parser<TToken>.CurrentSourcePosDelta);
-        }
 
         public static Parser<TToken, T> WithDebug<TToken, T>(this Parser<TToken, T> parser)
         {
@@ -100,24 +82,19 @@ public static Parser<TToken, T> BetweenAsThen<TToken, T, U, V>(this Parser<TToke
                 throw new ArgumentNullException(nameof(parser1));
             if (parser2 == null)
                 throw new ArgumentNullException(nameof(parser2));
-            return Parser.Map<TToken, U, T, V, T>(func, parser1, parser, parser2);
+
+            return Map(func, parser1, parser, parser2);
         }
 
         public static Parser<TToken, R> As<TToken, T, R>(this Parser<TToken, T> parser)
-            where T: R
-        {
-            return parser.Select(x => (R)x);
-        }
-
-        public static Parser<TToken, T> After<TToken, T, U>(this Parser<TToken, T> parser, Parser<TToken, U> parserAfter)
-        {
-            return parserAfter.Then(parser, (u, t) => t);
-        }
-
+            where T: R 
+            => parser.Select(x => (R)x);
+
+        public static Parser<TToken, T> After<TToken, T, U>(this Parser<TToken, T> parser, Parser<TToken, U> parserAfter) 
+            => parserAfter.Then(parser, (u, t) => t);
+
         // TODO optimization
-        public static Parser<char, T> ParenthesisedOptional<T, TResult>(this Parser<char, T> parser, Func<char, Parser<char, TResult>> custom)
-        {
-            return OneOf(CommonParser.Parenthesised(parser, custom).Try(), parser);
-        }
+        public static Parser<char, T> ParenthesisedOptional<T, TResult>(this Parser<char, T> parser, Func<char, Parser<char, TResult>> custom) 
+            => OneOf(CommonParser.Parenthesised(parser, custom).Try(), parser);
     }
 }

src/SimpleStateMachine.StructuralSearch/Extensions/StringExtensions.cs

@@ -5,8 +5,6 @@ namespace SimpleStateMachine.StructuralSearch.Extensions;
 
 public static class StringExtensions
 {
-    public static MemoryStream AsStream(this string str)
-    {
-        return new MemoryStream(Encoding.UTF8.GetBytes(str));
-    }
+    public static MemoryStream AsStream(this string str) 
+        => new(Encoding.UTF8.GetBytes(str));
 }