Есть такой метод:

        protected static IEnumerable<ParseResult<TResult>> Sequence<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(
            Func<LazyList<IToken>, IEnumerable<ParseResult<T1>>> parser1,
            Func<LazyList<IToken>, IEnumerable<ParseResult<T2>>> parser2,
            Func<LazyList<IToken>, IEnumerable<ParseResult<T3>>> parser3,
            Func<LazyList<IToken>, IEnumerable<ParseResult<T4>>> parser4,
            Func<LazyList<IToken>, IEnumerable<ParseResult<T5>>> parser5,
            Func<LazyList<IToken>, IEnumerable<ParseResult<T6>>> parser6,
            Func<LazyList<IToken>, IEnumerable<ParseResult<T7>>> parser7,
            Func<LazyList<IToken>, IEnumerable<ParseResult<T8>>> parser8,
            Func<LazyList<IToken>, IEnumerable<ParseResult<T9>>> parser9,
            Func<LazyList<IToken>, IEnumerable<ParseResult<T10>>> parser10,
            Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> nodeFactory,
            LazyList<IToken> tokens)
        {
            foreach (var productions in
                from production1 in parser1(tokens)
                from production2 in parser2(production1.Tokens)
                from production3 in parser3(production2.Tokens)
                from production4 in parser4(production3.Tokens)
                from production5 in parser5(production4.Tokens)
                from production6 in parser6(production5.Tokens)
                from production7 in parser7(production6.Tokens)
                from production8 in parser8(production7.Tokens)
                from production9 in parser9(production8.Tokens)
                from production10 in parser10(production9.Tokens)
                select new
                           {
                               Production1 = production1,
                               Production2 = production2,
                               Production3 = production3,
                               Production4 = production4,
                               Production5 = production5,
                               Production6 = production6,
                               Production7 = production7,
                               Production8 = production8,
                               Production9 = production9,
                               Production10 = production10,
                           })
            {
                yield return
                    new ParseResult<TResult>(
                        nodeFactory(
                            productions.Production1.Node,
                            productions.Production2.Node,
                            productions.Production3.Node,
                            productions.Production4.Node,
                            productions.Production5.Node,
                            productions.Production6.Node,
                            productions.Production7.Node,
                            productions.Production8.Node,
                            productions.Production9.Node,
                            productions.Production10.Node),
                        productions.Production10.Tokens,
                        productions.Production1.SavePoint);
                if (productions.Production1.SavePoint)
                    break;
            }
        }

На самом деле таких методов даже несколько — по одному для каждого количества аргументов. Естественно, объявлена куча типов Func<...>. Очевидное дублирование кода. Хотелось бы от него избавиться, не прибегая ни к кодогенерации, ни к более слабой типизации. Вопрос: есть ли системы типов, которые позволяют такое?