public void ShouldUnderstandLambdasAndApplyAnonymousFunctions()
        {
            var context = new LispContext();
            var expr    = ToyLispParser.ParseExpression("((lambda (x y) (+ x y)) 1 2)").Reduce(context);

            Assert.AreEqual("3", expr.ToString());
        }
        public void ShouldApplyFunctionToAtomsOrLists2()
        {
            var context = new LispContext();

            var expr1 = ToyLispParser.ParseExpression("(- (* (/ (+ 1 2) 3) 4) 5)").Reduce(context);

            Assert.AreEqual("-1", expr1.ToString());
        }
        public void ShouldReturnRightValueFromIfFunction()
        {
            var context = new LispContext();

            var expr1 = ToyLispParser.ParseExpression("(if 1 1 2)").Reduce(context);
            var expr2 = ToyLispParser.ParseExpression("(if '() 1 2)").Reduce(context);

            Assert.AreEqual("1", expr1.ToString());
            Assert.AreEqual("2", expr2.ToString());
        }
        public void ShouldApplyFunctionToAtomsOrLists3()
        {
            var context = new LispContext();

            var expr1 = ToyLispParser.ParseExpression("(+ (+ 3))").Reduce(context);
            var expr2 = ToyLispParser.ParseExpression("(- (- 3))").Reduce(context);

            Assert.AreEqual("3", expr1.ToString());
            Assert.AreEqual("3", expr2.ToString());
        }
Пример #5
0
        public static void Main(string[] args)
        {
            LispContext ctx = new LispContext();

            ctx.register("+", new LispAdd());
            ctx.register("get", new LispGet(ref ctx));
            ctx.register("set", new LispSet(ref ctx));
            ctx.register("range", new LispRange());
            ctx.register("store", new LispBoundValue(new LispFloating(0.001)));

            while (true)
            {
                Console.Write("> ");
                string n = Console.ReadLine();
                Console.WriteLine(ctx.evaluate(n).eval().getString());
            }
        }
Пример #6
0
        static void Main(string[] args)
        {
            var context = new LispContext();

            while (true)
            {
                Console.Write("<<< ");
                var input = Console.ReadLine();
                try
                {
                    var expression = ToyLispParser.ParseExpression(input).Reduce(context);
                    Console.WriteLine(">>> {0}", expression);
                }
                catch (CloseReplException)
                {
                    break;
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                }
                Console.WriteLine();
            }
        }
Пример #7
0
        public override LispExpression Apply(IEnumerable <LispExpression> expressions, LispContext context)
        {
            var e = expressions as LispExpression[] ?? expressions.ToArray();

            CanBeCalledWithOnlyNArguments(Id, e, 2);
            var id    = e[0].ToString();
            var value = e[1].Reduce(context);

            context[id] = value;
            return(value);
        }
Пример #8
0
        public override LispExpression Apply(IEnumerable <LispExpression> expressions, LispContext context)
        {
            var e = expressions as LispExpression[] ?? expressions.ToArray();

            CannotBeCalledWithZeroArguments(Id, e);
            if (e.Length == 1)
            {
                var number = ((LispAtom)e.ElementAt(0).Reduce(context)).ToDecimal();
                return(new LispAtom(number.ToString(CultureInfo.InvariantCulture)));
            }
            return(new LispAtom(e.Select(a => a.Reduce(context))
                                .Cast <LispAtom>()
                                .Select(a => a.ToDecimal())
                                .Sum()
                                .ToString(CultureInfo.InvariantCulture)));
        }
Пример #9
0
        public override LispExpression Apply(IEnumerable <LispExpression> expressions, LispContext context)
        {
            var e = expressions as LispExpression[] ?? expressions.ToArray();

            CanBeCalledWithOnlyNArguments(Id, e, 3);
            return(e[0].Reduce(context).ToString() != "()" ? e[1].Reduce(context) : e[2].Reduce(context));
        }
Пример #10
0
        public override LispExpression Apply(IEnumerable <LispExpression> expressions, LispContext context)
        {
            var e = expressions as LispExpression[] ?? expressions.ToArray();

            CannotBeCalledWithFewerThanNArguments(Id, e, 2);
            return(new LispAtom(e.Select(a => a.Reduce(context))
                                .Cast <LispAtom>()
                                .Select(a => a.ToDecimal())
                                .Aggregate(1m, (current, d) => current * d)
                                .ToString(CultureInfo.InvariantCulture)));
        }
Пример #11
0
        public override LispExpression Apply(IEnumerable <LispExpression> expressions, LispContext context)
        {
            var e = expressions as LispExpression[] ?? expressions.ToArray();

            CanBeCalledWithOnlyNArguments(Id, e, 2);
            var arguments = ((LispList)e[0]).Expressions.OfType <LispAtom>().Select(a => a.ToString()).ToArray();

            return(new AnonymousFunction(arguments, e[1]));
        }
Пример #12
0
        public override LispExpression Apply(IEnumerable <LispExpression> expressions, LispContext context)
        {
            var e = expressions as LispExpression[] ?? expressions.ToArray();

            CannotBeCalledWithZeroArguments(Id, e);
            if (e.Length == 1)
            {
                var number = ((LispAtom)e.ElementAt(0).Reduce(context)).ToDecimal();
                return(new LispAtom((-number).ToString(CultureInfo.InvariantCulture)));
            }
            var result = ((LispAtom)e.ElementAt(0).Reduce(context)).ToDecimal();

            result = e.Skip(1)
                     .Select(a => a.Reduce(context))
                     .Cast <LispAtom>()
                     .Select(a => a.ToDecimal())
                     .Aggregate(result, (current, d) => current - d);
            return(new LispAtom(result.ToString(CultureInfo.InvariantCulture)));
        }