public ComposeResult <TranslationUnit> Compose(ICollection <Token> tokens)
        {
            var result = new TranslationUnit();

            var declarationComposer = ComposerFactory.Create <Declaration>();

            result.Declarations = InfiniteSequence.Create <int>()
                                  .Select(v =>
            {
                var r  = declarationComposer.Compose(tokens);
                tokens = r.Tokens;
                return(r.Result);
            })
                                  .TakeWhile(v => v.HasValue)
                                  .Select(v => v.Value)
                                  .ToList();

            var statementComposer = ComposerFactory.Create <Statement>();

            result.Statements = InfiniteSequence.Create <int>()
                                .Select(v =>
            {
                var r  = statementComposer.Compose(tokens);
                tokens = r.Tokens;
                return(r.Result);
            })
                                .TakeWhile(v => v.HasValue)
                                .Select(v => v.Value)
                                .ToList();

            return(new ComposeResult <TranslationUnit> {
                Result = result.ToMaybe(), Tokens = tokens
            });
        }
        public void FailWhenExecutedOnAnInfiniteSequence()
        {
            var infiniteSequence = new InfiniteSequence();

            Assert.Throws <OverflowException>(() =>
            {
                var sum = infiniteSequence.Sum();
            });
        }
예제 #3
0
        public void BeExecutableOnInfiniteSequences()
        {
            var infiniteSequence = new InfiniteSequence();

            var first10LessThanAMillion = infiniteSequence.Where(i => i < 1000000)
                                          .Take(10)
                                          .ToArray();

            Assert.Equal(10, first10LessThanAMillion.Length);
        }