Рефакторинг лексера

Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
 
            #region Constant Regex
 
            const string DigitPattern = @"\d*\.?\d+(?:[eE][\-+]?\d+)?";
            const string IdentifierPattern = @"[A-Za-z]+";
            const string OperationPattern = @"[+\-*\/\^\(\)\,\!]";
 
            #endregion
 
            #region Token Init 
 
            bool afterOperand = false;
            var tokens = Regex.Matches("12    - 9 * 23.55 - (cos(2 * pi ^ 2) ) - e * 1.233E+3",
                // string.Join("|", OperationPattern, IdentifierPattern, DigitPattern)
                $"({OperationPattern})|({IdentifierPattern})|({DigitPattern})",
                RegexOptions.Compiled | RegexOptions.IgnoreCase)
                .Cast<Match>()
                .Where(m => !string.IsNullOrEmpty(m.Value))
                .Select(m =>
                {
                    string t = m.Value.Trim();
                    LexemType l;
                    Match next = m.NextMatch();
    
                    if (Regex.IsMatch(t, DigitPattern)) // 12 + - - - 11
                    {
                        if (afterOperand)
                        {
                            t.Insert(0, "-");
                            afterOperand = false;
                        }
                        
                        return (t.StartsWith("0x")) ? new Lexem(LexemType.HexNumber, t, m.Index) 
                                : (t.StartsWith("0b")) ? new Lexem(LexemType.BinaryNumber, t, m.Index)
                                : new Lexem(LexemType.Number, t, m.Index);
                    }
                    else if (Regex.IsMatch(t, IdentifierPattern))
                        return (next.Value == "(") // next.Value.In("(", "[", "{")
                                ? new Lexem(LexemType.Function, t, m.Index)
                                : new Lexem(LexemType.Variable, t, m.Index);
                    else if (Regex.IsMatch(t, OperationPattern))
                        return new Lexem()
                        {
                            Type = LexemType.Operator,
                            Value = t,
                            Position = m.Index
                        };
                    else if (Regex.IsMatch(t, IdentifierPattern))
                    {
                        string nextValue = next.Value;
                        if (nextValue == "+" ||
                            nextValue == "-")
                        {
                            next.Result("");
                            afterOperand = true;
                        }
 
                        switch (t)
                        {
                            case "+":
                                if (nextValue == "-")
                                {
                                    l = LexemType.Minus;
                                    break;
                                }
                                l = LexemType.Plus;
                                break;
                            case "-":
                                if (nextValue == "-")
                                {
                                    l = LexemType.Plus;
                                    break;
                                }
                                l = LexemType.Minus;
                                break;
                            case "*":
                                l = LexemType.Star;
                                break;
                            case "/":
                                l = LexemType.Slash;
                                break;
                            case "**":
                                l = LexemType.StarStar;
                                break;
                            case "^":
                                l = LexemType.Pow;
                                break;
                            case "!":
                                l = LexemType.Exclamation;
                                break;
                            default:
                                l = LexemType.Comma;
                                break;
                        }
 
                        return new Lexem()
                        {
                            Type = l,
                            Value = t,
                            Position = m.Index
                        };
                    }
                    // если токен не определен, возвращаем пустой токен
                    
                    return new Lexem();
                })
                .OrderBy(l => l.Position)
                .ToList();
 
            #endregion
 
            foreach (Lexem token in tokens)
            {
                Console.WriteLine(token);
            }

public enum LexemType
    {
        Variable,
        Function,
        Identifier,
        Number,
        HexNumber,
        BinaryNumber,
        OpenSub,
        CloseSub,
        Comma,
        Plus,
        Minus,
        Star,
        Slash,
        Pow,
        StarStar,
        Exclamation,
        None
    }
 
    public class Lexem
    {
        public LexemType Type { get; set; }
        public string Value { get; set; }
        public int Position { get; set; }
        public bool Empty => this.Type == LexemType.None;
 
        public Lexem()
        {
            Type = LexemType.None;
            Value = string.Empty;
            Position = -1;
        }
 
        public Lexem(LexemType type, string value, int position)
        {
            this.Type = type;
            this.Value = value;
            this.Position = position;
        }
 
        public override string ToString()
        {
            return $"{Type} : {Value,2} {Position,2}";
        }
    }