C# ScheminPair.ListCdr方法代码示例

        public override IScheminType Execute(Environment env, Evaluator eval, ScheminPair args)
        {
            IScheminType key = args.Car;
            ScheminPair checks = args.ListCdr();

            foreach (IScheminType type in checks)
            {
                ScheminPair pairCase = (ScheminPair) type;
                IScheminType group = pairCase.Car;
                IScheminType result = pairCase.ListCdr().Car;

                if ((group as ScheminAtom) != null)
                {
                    ScheminAtom atomClause = (ScheminAtom) group;
                    if (atomClause.Name == "else")
                    {
                        return result;
                    }
                    else
                    {
                        throw new Exception("atom besides 'else' found in case statement");
                    }
                }

                ScheminPair pairGroup = (ScheminPair) group;
                foreach (IScheminType checkType in pairGroup)
                {
                    if (key.Equivalent(checkType))
                        return result;
                }
            }

            return new ScheminPair();
        }

        public override IScheminType Execute(Environment env, Evaluator eval, ScheminPair args)
        {
            ScheminVector vec = (ScheminVector) args.Car;
            ScheminInteger pos = (ScheminInteger) args.ListCdr().Car;

            int pos_int = (int) pos.IntegerValue();
            return vec.List[pos_int];
        }

        public ScheminLambda(ScheminPair definition, Environment closure)
        {
            this.Arguments = definition.Car;

            ScheminPair def = definition.ListCdr();
            def = def.Cons(new ScheminPrimitive("begin"));
            this.Definition = def;

            this.Closure = closure;
        }

        public override IScheminType Execute(Environment env, Evaluator eval, ScheminPair args)
        {
            ScheminVector vec = (ScheminVector) args.Car;
            IScheminType fill = args.ListCdr().Car;

            for (int i = 0; i < vec.List.Count; i++)
            {
                vec.List[i] = fill;
            }

            return new ScheminPair();
        }

        public override IScheminType Execute(Environment env, Evaluator eval, ScheminPair args)
        {
            IScheminType function = args.Car;
            ScheminPair argList = args.ListCdr();
            ScheminPair toApply = (ScheminPair) args.ListCdr().Last();

            ScheminPair list = new ScheminPair();
            foreach (IScheminType type in toApply)
            {
                list = list.Append(type);
            }

            foreach (IScheminType type in argList)
            {
                if (type != toApply)
                    list = list.Cons(type);
            }

            list = list.Cons(function);

            return list;
        }

        public override IScheminType Execute(Environment env, Evaluator eval, ScheminPair args)
        {
            bool dec = false;
            var first = (IScheminNumeric) args.Car;
            IScheminNumeric result = null;

            foreach (IScheminType type in args)
            {
                if ((type as ScheminDecimal) != null)
                {
                    dec = true;
                    result = new ScheminDecimal(first.DecimalValue());
                }
            }

            if (!dec)
            {
                result = new ScheminInteger(first.IntegerValue());
            }

            if (args.Length < 2)
            {
                if (dec)
                {
                    return new ScheminDecimal(first.DecimalValue() * -1);
                }
                else
                {
                    return new ScheminInteger(first.IntegerValue() * -1);
                }
            }

            foreach (IScheminType type in args.ListCdr())
            {
                if ((type as IScheminNumeric) != null)
                {
                    var temp = (IScheminNumeric) type;
                    if (dec)
                    {
                        result = new ScheminDecimal(result.DecimalValue() - temp.DecimalValue());
                    }
                    else
                    {
                        result = new ScheminInteger(result.IntegerValue() - temp.IntegerValue());
                    }
                }
            }

            return (IScheminType) result;
        }

        public override void CheckArguments(ScheminPair args)
        {
            IScheminType first = args.Car;
            IScheminType second = args.ListCdr().Car;

            if (args.Length != 2)
            {
                throw new BadArgumentsException("expected 2 arguments");
            }

            if ((first as IScheminNumeric) == null || (second as IScheminNumeric) == null)
            {
                throw new BadArgumentsException("arguments must be numeric");
            }

            return;
        }

        public override void CheckArguments(ScheminPair args)
        {
            IScheminType first = args.Car;
            IScheminType second = args.ListCdr().Car;

            if (args.Length > 2 || args.Length < 1)
            {
                throw new BadArgumentsException("expected 1 or 2 arguments");
            }

            if ((first as ScheminInteger) == null)
            {
                throw new BadArgumentsException("first argument must be an integer");
            }

            return;
        }

        public override void CheckArguments(ScheminPair args)
        {
            IScheminType first = args.Car;
            IScheminType last = args.ListCdr().Last();

            if ((first as ScheminPrimitive) == null && (first as ScheminLambda) == null
                    && (first as ScheminContinuation) == null && (first as ScheminRewriter) == null)
            {
                throw new BadArgumentsException("first argument must be a procedure");
            }

            if ((last as ScheminPair) == null)
            {
                throw new BadArgumentsException("last argument must be a list");
            }

            return;
        }

        public override IScheminType Execute(Environment env, Evaluator eval, ScheminPair args)
        {
            ScheminInteger len = (ScheminInteger) args.Car;
            IScheminType init = args.ListCdr().Car;

            ScheminVector vec = new ScheminVector();
            if (args.Length == 1)
            {
                ScheminPair empty = new ScheminPair();
                for (int i = 0; i < len.IntegerValue(); i++)
                {
                    vec.List.Add(empty);
                }
            }
            else
            {
                for (int i = 0; i < len.IntegerValue(); i++)
                {
                    vec.List.Add(init);
                }
            }

            return vec;
        }

        public override IScheminType Execute(Environment env, Evaluator eval, ScheminPair args)
        {
            bool isNamed = false;
            if ((args.Car as ScheminAtom) != null)
            {
                isNamed = true;
            }

            ScheminPair bindings;
            ScheminPair expression;

            if (!isNamed)
            {
                expression = args.ListCdr();
                bindings = (ScheminPair)args.Car;
            }
            else
            {
                expression = args.ListCdr().ListCdr();
                bindings = (ScheminPair)args.ElementAt(1);
            }

            ScheminPair letArgs = new ScheminPair();
            ScheminPair argExps = new ScheminPair();

            foreach (ScheminPair bindingPair in bindings)
            {
                letArgs = letArgs.Append(bindingPair.Car);
                argExps = argExps.Append(bindingPair.ElementAt(1));
            }

            ScheminPair lambdaDef = new ScheminPair(letArgs);

            foreach (IScheminType type in expression)
            {
                lambdaDef = lambdaDef.Append(type);
            }

            Environment closure = env;
            if (isNamed)
            {
                closure = new Environment();
                closure.parent = env;
            }

            ScheminLambda lam = new ScheminLambda(lambdaDef, closure);

            if (isNamed)
            {
                ScheminAtom name = (ScheminAtom)args.Car;
                closure.AddBinding(name, lam);
            }

            ScheminPair toEvaluate = new ScheminPair(lam);

            foreach (IScheminType arg in argExps)
            {
                toEvaluate = toEvaluate.Append(arg);
            }

            return toEvaluate;
        }

        public override IScheminType Execute(Environment env, Evaluator eval, ScheminPair args)
        {
            bool deffun = false;

            if ((args.Car as ScheminPair) != null)
            {
                deffun = true;
            }

            if (!deffun)
            {
                ScheminAtom symbol = (ScheminAtom) args.ElementAt(0);
                IScheminType definition = args.ElementAt(1);

                if (env.bindings.ContainsKey(symbol.Name))
                {
                    env.RemoveBinding(symbol);
                    env.AddBinding(symbol, definition);
                }
                else
                {
                    env.AddBinding(symbol, definition);
                }

                return new ScheminPair();
            }
            else
            {
                ScheminPair arguments = (ScheminPair) args.Car;
                ScheminPair expression = args.ListCdr();

                ScheminAtom name = (ScheminAtom) arguments.Car;
                IScheminType lamParams = arguments.Cdr;

                if (lamParams == null)
                    lamParams = new ScheminPair();
                ScheminPair lamArgs = new ScheminPair(lamParams, expression);

                ScheminLambda lam = new ScheminLambda(lamArgs, env);

                if (env.bindings.ContainsKey(name.Name))
                {
                    env.RemoveBinding(name);
                    env.AddBinding(name, lam);
                }
                else
                {
                    env.AddBinding(name, lam);
                }

                return new ScheminPair();
            }
        }