public static new StringUpcaseExpression?Parse(string str)
        {
            List <IRacketObject>?arguments = RacketParsingHelper.ParseRacketStrings(str);

            if (arguments?.Count == 1)
            {
                return(new StringUpcaseExpression(arguments));
            }
            return(null);
        }
Esempio n. 2
0
        public static new ExponentEpression?Parse(string str)
        {
            List <IRacketObject>?arguments = RacketParsingHelper.ParseRacketNumbers(str);

            if (arguments?.Count > 1)
            {
                return(new ExponentEpression(arguments));
            }
            return(null);
        }
Esempio n. 3
0
        public static new IsBooleanExpression?Parse(string str)
        {
            List <IRacketObject>?arguments = RacketParsingHelper.ParseAny(str);

            if (arguments?.Count == 1)
            {
                return(new IsBooleanExpression(arguments));
            }
            return(null);
        }
Esempio n. 4
0
        public static new LeastCommonMultipleExpression?Parse(string str)
        {
            List <IRacketObject>?arguments = RacketParsingHelper.ParseRacketIntegers(str);

            if (arguments?.Count > 1)
            {
                return(new LeastCommonMultipleExpression(arguments));
            }
            return(null);
        }
Esempio n. 5
0
        public static new BooleanOrExpression?Parse(string str)
        {
            List <IRacketObject>?arguments = RacketParsingHelper.ParseRacketBooleans(str);

            if (arguments?.Count > 0)
            {
                return(new BooleanOrExpression(arguments));
            }
            return(null);
        }
Esempio n. 6
0
        public static new ModuloExpression?Parse(string str)
        {
            List <IRacketObject>?arguments = RacketParsingHelper.ParseRacketIntegers(str);

            if (arguments?.Count > 0)
            {
                return(new ModuloExpression(arguments));
            }
            return(null);
        }
        public static new NaturalLogarithmExpression?Parse(string str)
        {
            List <IRacketObject>?arguments = RacketParsingHelper.ParseRacketNumbers(str);

            if (arguments?.Count == 1)
            {
                return(new NaturalLogarithmExpression(arguments));
            }
            return(null);
        }
Esempio n. 8
0
        public static new IfExpression?Parse(string str)
        {
            List <IRacketObject>?arguments = RacketParsingHelper.ParseAny(str);

            if (arguments?.Count == 3)
            {
                RacketParsingHelper.ValidateReturnType(typeof(RacketBoolean), arguments[0]);
                return(new IfExpression(arguments));
            }
            return(null);
        }
Esempio n. 9
0
        public static new RandomExpression?Parse(string str)
        {
            List <IRacketObject>?arguments = RacketParsingHelper.ParseRacketIntegers(str);

            if (arguments?.Count == 1 && arguments[0] is RacketExpression)
            {
                return(new RandomExpression(arguments));
            }
            else if (arguments?.Count == 1 && ((RacketInteger)arguments[0]).IsNatural)
            {
                return(new RandomExpression(arguments));
            }
            return(null);
        }