/// <summary>
/// Creates a transducer that passes all input through all of the supplied transducers.
/// </summary>
/// <typeparam name="TInput">The input to the original transducer</typeparam>
/// <typeparam name="TMultiInput">The input to the multi-transducers</typeparam>
/// <typeparam name="TResult">The result of each transducer</typeparam>
/// <param name="transducer">The original transducer</param>
/// <param name="transducers">The multiplexed transducers</param>
/// <returns>A transducer that multiplexes the original transducers' results</returns>
public static ITransducer <TInput, TResult> Multiplexing <TInput, TMultiInput, TResult>(
this ITransducer <TInput, TMultiInput> transducer,
params ITransducer <TMultiInput, TResult>[] transducers) => transducer.Compose(Multiplexing(transducers));
/// <summary>
/// Produces a transducer that parses the results of the supplied transducer.
/// </summary>
/// <typeparam name="TInput">The type of the input.</typeparam>
/// <typeparam name="TResult">The type of the result.</typeparam>
/// <param name="transducer">The transducer.</param>
/// <returns>A transducer whose results are parsed from the results of the supplied transducer.</returns>
public static ITransducer <TInput, TResult> Parsing <TInput, TResult>(
this ITransducer <TInput, string> transducer) where TResult : struct =>
transducer.Compose(Parsing <TResult>());
/// <summary>
/// Produces a transducer that takes multiple values from this transducer at a time.
/// Each input pushes previous values out of the window of values supplied. Does not
/// produce a window until it's filled.
/// </summary>
/// <typeparam name="TInput">The input to the original and new transducer</typeparam>
/// <typeparam name="TResult">The result of the original transducer</typeparam>
/// <param name="transducer">The original transducer</param>
/// <param name="windowSize">The size of the produced window</param>
/// <returns>A sliding transducer</returns>
public static ITransducer <TInput, IList <TResult> > Sliding <TInput, TResult>(
this ITransducer <TInput, TResult> transducer,
int windowSize) => transducer.Compose(Sliding <TResult>(windowSize));
public static ITransducer <TInput, TResult> UncheckedSumming <TInput, TResult>(
this ITransducer <TInput, IList <TResult> > transducer) where TResult : struct =>
transducer.Compose(UncheckedSumming <TResult>());
/// <summary>
/// Produces a feedback transducer composed with this transducer.
/// </summary>
/// <typeparam name="TInput">The input to the new transducer</typeparam>
/// <typeparam name="TResult">The result and feedback type</typeparam>
/// <param name="transducer">The original transducer</param>
/// <param name="operation">The feedback operation.</param>
/// <returns>A feedback transducer</returns>
public static ITransducer <TInput, TResult> Feedback <TInput, TResult>(
this ITransducer <TInput, TResult> transducer,
ITransducer <TResult, TResult> operation) => transducer.Compose(Feedback(operation));
/// <summary>
/// Produces a transducer that composes the input transducer and restricts the type of the results from it.
/// </summary>
/// <typeparam name="TInput">The input to the new transducer</typeparam>
/// <typeparam name="TBase">The original type of the transducer</typeparam>
/// <typeparam name="TDerived">The restricted type of the transducer</typeparam>
/// <param name="transducer">The original transducer</param>
/// <returns>A new transducer that restricts the produced type</returns>
public static ITransducer <TInput, TDerived> Casting <TInput, TBase, TDerived>(
this ITransducer <TInput, TBase> transducer) where TDerived : TBase =>
transducer.Compose(Casting <TBase, TDerived>());
/// <summary>
/// Produces a transducer that erases the type of the values produced by the supplied transducer.
/// </summary>
/// <typeparam name="TInput">The type of the input.</typeparam>
/// <typeparam name="TResult">The type of the results of the original transducer.</typeparam>
/// <param name="transducer">The transducer.</param>
/// <returns>An erasing transducer.</returns>
public static ITransducer <TInput, object> Erasing <TInput, TResult>(
this ITransducer <TInput, TResult> transducer) =>
transducer.Compose(Relaxing <TResult, object>());
/// <summary>
/// Produces a transducer that relaxes the result type of the supplied transducer.
/// </summary>
/// <typeparam name="TInput">The type of the input.</typeparam>
/// <typeparam name="TDerived">The type produced by the original transducer.</typeparam>
/// <typeparam name="TBase">The type produced by the relaxed transducer.</typeparam>
/// <param name="transducer">The transducer.</param>
/// <returns>A transducer that produces values of a relaxed type.</returns>
public static ITransducer <TInput, TBase> Relaxing <TInput, TDerived, TBase>(this ITransducer <TInput, TDerived> transducer)
where TDerived : TBase =>
transducer.Compose(Relaxing <TDerived, TBase>());
/// <summary>
/// Creates a new transducer that composes some transducer with a transducer that maps
/// values given some mapping function.
/// </summary>
/// <typeparam name="TInput">The type of the input to the starting and resulting transducer.</typeparam>
/// <typeparam name="TMedium">The type of the values commuted from the starting transducer and the mapping function.</typeparam>
/// <typeparam name="TResult">The type of the values being mapped to.</typeparam>
/// <param name="transducer">The transducer being mapped from.</param>
/// <param name="map">The mapping function.</param>
/// <returns>A transducer that maps values from the supplied transducer to values being produced from the new transducer.</returns>
public static ITransducer <TInput, TResult> Mapping <TInput, TMedium, TResult>(
this ITransducer <TInput, TMedium> transducer, Func <TMedium, TResult> map) => transducer.Compose(Mapping(map));