private static ComparisonType GetComparingToken(List <Token> tokens)
        {
            TokenType ttype = (tokens.Where(x => TokenGroups.IsComparingSign(x.GetTokenType())).First()).GetTokenType();

            switch (ttype)
            {
            case TokenType.Equals:
                return(ComparisonType.Equals);

            case TokenType.NotEquals:
                return(ComparisonType.NotEquals);

            case TokenType.Bigger:
                return(ComparisonType.Bigger);

            case TokenType.BiggerOrEquals:
                return(ComparisonType.BiggerOrEquals);

            case TokenType.Smaller:
                return(ComparisonType.Smaller);

            case TokenType.SmallerOrEquals:
                return(ComparisonType.SmallerOrEquals);
            }
            return(ComparisonType.Equals);
        }
        private static IBoolable BuildComparison(List <Token> tokens)
        {
            int index = tokens.TakeWhile(x => !TokenGroups.IsComparingSign(x.GetTokenType())).Count();

            if (index == 0 || index == tokens.Count - 1)
            {
                return(null);
            }

            ComparisonType type        = GetComparingToken(tokens);
            List <Token>   leftTokens  = tokens.GetRange(0, index);
            List <Token>   rightTokens = tokens.GetRange(index + 1, tokens.Count - index - 1);
            IListable      leftL       = ListableBuilder.Build(leftTokens);
            IListable      rightL      = ListableBuilder.Build(rightTokens);

            if (leftL.IsNull() || rightL.IsNull())
            {
                return(null);
            }

            if (leftL is INumerable && rightL is INumerable)
            {
                return(new NumericComparison(leftL as INumerable, rightL as INumerable, type));
            }

            if (leftL is ITimeable && rightL is ITimeable)
            {
                return(new TimeComparison(leftL as ITimeable, rightL as ITimeable, type));
            }

            if (leftL is IStringable && rightL is IStringable)
            {
                return(new Uroboros.syntax.expressions.bools.comparisons.StringComparison(leftL as IStringable, rightL as IStringable, type));
            }

            if (leftL is IListable && rightL is IListable)
            {
                return(new ListComparison(leftL as IListable, rightL as IListable, type));
            }

            return(null);
        }
 private static bool ContainsOneComparingToken(List <Token> tokens)
 {
     return(tokens.Where(x => TokenGroups.IsComparingSign(x.GetTokenType())).Count() == 1);
 }
 private static bool ContainsComparingTokens(List <Token> tokens)
 {
     return(tokens.Where(x => TokenGroups.IsComparingSign(x.GetTokenType())).Any());
 }