public static IObservable <TResult> ParseString <TResult>( this IObservable <char> source, Func <StringObservableParserQueryContext <char, IObservableParser <char, char> >, StringObservableParserQueryContext <char, IObservableParser <char, IObservable <TResult> > > > grammarSelector) { Contract.Requires(source != null); Contract.Requires(grammarSelector != null); Contract.Ensures(Contract.Result <IObservable <TResult> >() != null); var parser = new InlineStringObservableParser <IObservable <TResult> >(); var proxyParser = (IStringObservableParser <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 StringObservableParserQueryContext <char, IObservableParser <char, char> >( proxyParser, parser.Next); var grammar = grammarSelector(context); Contract.Assume(grammar != null); IObservableParser <char, IObservable <TResult> > start = grammar.Value; Contract.Assume(start != null); // enableBranchOptimizations must be false: See the comments in the first Rxx.Parsers.Linq.Parser.Parse method for details. return(parser.Parse(source.ToCursor(forwardOnly: true, enableBranchOptimizations: false), start).Concat()); }
/// <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 StringObservableParserQueryContext <TParseResult, TResult> Select <TParseResult, TSource, TResult>( this StringObservableParserQueryContext <TParseResult, TSource> source, Func <TSource, TResult> selector) { Contract.Requires(source != null); Contract.Requires(selector != null); Contract.Ensures(Contract.Result <StringObservableParserQueryContext <TParseResult, TResult> >() != null); return(new StringObservableParserQueryContext <TParseResult, TResult>( source.Parser, selector(source.Value))); }