/// <summary>
        /// Enables defining in-line parser grammars using LINQ.
        /// </summary>
        /// <typeparam name="TParseResult">The type of the elements that are originally generated from parsing the source elements.</typeparam>
        /// <typeparam name="TSource">The type of the source elements; typically, this will be an anonymous compiler-generated type.</typeparam>
        /// <typeparam name="TResult">The type of the elements that are generated from parsing the source elements.</typeparam>
        /// <param name="source">The parser query context to be projected.</param>
        /// <param name="selector">A function that projects the current result of the query context.</param>
        /// <returns>A new query context that is the projection of the specified query context using the specified <paramref name="selector"/>.</returns>
        public static XmlParserQueryContext <TParseResult, TResult> Select <TParseResult, TSource, TResult>(
            this XmlParserQueryContext <TParseResult, TSource> source,
            Func <TSource, TResult> selector)
        {
            Contract.Requires(source != null);
            Contract.Requires(selector != null);
            Contract.Ensures(Contract.Result <XmlParserQueryContext <TParseResult, TResult> >() != null);

            return(new XmlParserQueryContext <TParseResult, TResult>(
                       source.Parser,
                       selector(source.Value)));
        }
        public static IEnumerable <TResult> ParseXml <TResult>(
            this IEnumerable <char> source,
            Func <XmlParserQueryContext <char, IParser <char, char> >,
                  XmlParserQueryContext <char, IParser <char, IEnumerable <TResult> > > > grammarSelector)
        {
            Contract.Requires(source != null);
            Contract.Requires(grammarSelector != null);
            Contract.Ensures(Contract.Result <IEnumerable <TResult> >() != null);

            var parser      = new InlineXmlParser <IEnumerable <TResult> >();
            var proxyParser = (IXmlParser <char>)parser;

            // The proxy allows the grammar author to use base methods such as Success and Failure
            // while still allowing type inference to work correctly; i.e., the Parse method is unavailable
            // and thus the type of the proxy is based solely on TSource, without requiring TResult to
            // be in an input position in grammarSelector.
            var context = new XmlParserQueryContext <char, IParser <char, char> >(
                proxyParser,
                parser.Next);

            var grammar = grammarSelector(context);

            Contract.Assume(grammar != null);

            IParser <char, IEnumerable <TResult> > start = grammar.Value;

            Contract.Assume(start != null);

            // enableBranchOptimizations must be false: See the comments in the first Parse extension for details.
            using (var cursor = source.ToCursor(forwardOnly: true, enableBranchOptimizations: false))
            {
                foreach (var result in parser.Parse(cursor, start).Concat())
                {
                    yield return(result);
                }
            }
        }