public List <ExoAtom> Execute(List <ExoAtom> input)
        {
            var hs1 = (input[0].ValueCore as HashSetValueCore).Values;

            hs1.UnionWith((input[2].ValueCore as HashSetValueCore).Values);
            var merge = new ExoAtom(hs1);

            return(new List <ExoAtom>()
            {
                merge
            });
        }
Пример #2
0
        private void ExecuteFunctions(List <Branch <ExoAtom> > subexpression)
        {
            bool    funcMode   = false;
            ExoAtom funcLink   = null;
            var     totalCount = subexpression.Count;

            for (int i = 0; i < totalCount; i++)
            {
                Branch <ExoAtom> branch = subexpression[i];
                if (funcMode)
                {
                    var function = funcLink.GetFunction(this.Parent);
                    var funcRes  = function.Execute(branch, this).ToList();

                    if (funcRes.Count > 1)
                    {
                        if (subexpression.Count == 2)
                        {
                            subexpression.RemoveAt(i);
                            subexpression.RemoveAt(i - 1);

                            i = totalCount;

                            foreach (var item in funcRes)
                            {
                                this.Parent.AddCommand(new ExoExpressionCommand(item));
                            }
                        }
                    }
                    else
                    {
                        subexpression.RemoveAt(i);
                        subexpression.RemoveAt(i - 1);
                        subexpression.Add(funcRes[0].ToBranch());
                        totalCount = subexpression.Count;
                        i--;
                    }
                }

                if (branch.Content?.IdentifiedType == ExoAtomType.func)
                {
                    funcLink = branch.Content;
                    funcMode = true;
                }
                else
                {
                    funcMode = false;
                }
            }
        }
        public bool Add(ExoAtom input)
        {
            if (input.IdentifiedType == ExoAtomType.prim)
            {
                var result = ResolveStack();
                Results.Add(input);
                return(result);
            }
            else
            {
                Stack.Add(input);

                if (CanResolve())
                {
                    return(ResolveStack());
                }

                return(false);
            }
        }