Esempio n. 1
0
        public static List Select <T>(this List list, Func <T, Object> transform) where T : Object
        {
            if (list is Null)
            {
                return(Null.Instance);
            }
            IDictionary <Pair, Pair> transformations = new Dictionary <Pair, Pair>();
            Pair current = list as Pair;
            Pair resultStart, resultCurrent;

            resultStart = resultCurrent = new Pair(transform(current.Car as T));
            while (current != null && !transformations.ContainsKey(current))
            {
                transformations.Add(current, resultCurrent);
                current = current.Cdr as Pair;
                if (current != null && !transformations.ContainsKey(current))
                {
                    resultCurrent = resultCurrent.Append(transform(current.Car as T));
                }
            }
            if (current != null)
            {
                resultCurrent.Cdr = transformations[current];
            }
            return(resultStart);
        }
Esempio n. 2
0
        public void AppendTest()
        {
            Pair list = Pair.GetList(1, 4);

            Pair result = Pair.Append(list, 9);

            Assert.Equal(9, result.Next.Next.Value);
        }
Esempio n. 3
0
        public static List Filter <T>(this List list, Func <T, bool> predicate) where T : Object
        {
            if (list is Null)
            {
                return(Null.Instance);
            }
            Pair           current      = list as Pair;
            HashSet <Pair> visitedPairs = new HashSet <Pair>();

            while (current != null && !predicate(current.Car as T) && visitedPairs.Add(current))
            {
                current = current.Cdr as Pair;
            }
            if (current == null || visitedPairs.Contains(current))
            {
                return(Null.Instance);
            }
            Pair resultStart, resultCurrent;

            resultStart = resultCurrent = new Pair(current.Car);
            Dictionary <Pair, Pair> successfulPairs = new Dictionary <Pair, Pair> {
                { current, resultStart },
            };

            current = current.Cdr as Pair;
            while (current != null && visitedPairs.Add(current))
            {
                if (predicate(current.Car as T))
                {
                    resultCurrent = resultCurrent.Append(current.Car);
                    successfulPairs.Add(current, resultCurrent);
                }
                current = current.Cdr as Pair;
            }
            if (current != null)
            {
                Pair startOfCycle = current;
                while (!successfulPairs.ContainsKey(current))
                {
                    current = current.Cdr as Pair;
                    if (current == startOfCycle)
                    {
                        break;
                    }
                }
                resultCurrent.Cdr = successfulPairs[current];
            }
            return(resultStart);
        }
Esempio n. 4
0
 public override Object VisitPair([NotNull] KernelParser.PairContext context)
 {
     if (context.dot != null)
     {
         Object[] expressions = context.expression().Select(VisitExpression).ToArray();
         Pair     start, pair;
         start = pair = new Pair(expressions[0]);
         for (int i = 1; i < expressions.Length - 1; i++)
         {
             pair = pair.Append(expressions[i]);
         }
         pair.Cdr = expressions[expressions.Length - 1];
         return(start);
     }
     return(new Pair(context.expression().Select(VisitExpression)));
 }