using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;

namespace Chernobyl
{
    /// <summary>
    /// Extension and utility types for <see cref="Func{TResult}"/> and related
    /// types.
    /// </summary>
    public static class Func
    {
        /// <summary>
        /// Returns <paramref name="func"/>. This method makes writing in a fluent style a little easier.
        /// </summary>
        public static Func<T> This<T>(Func<T> func) => func;

        /// <summary>
        /// Returns <paramref name="func"/>. This method makes writing in a fluent style a little easier.
        /// </summary>
        public static Func<T1, TReturn> This<T1, TReturn>(Func<T1, TReturn> func) => func;

        /// <summary>
        /// Returns <paramref name="func"/>. This method makes writing in a fluent style a little easier.
        /// </summary>
        public static Func<T1, T2, TReturn> This<T1, T2, TReturn>(Func<T1, T2, TReturn> func) => func;

        /// <summary>
        /// Returns <paramref name="func"/>. This method makes writing in a fluent style a little easier.
        /// </summary>
        public static Func<T1, T2, T3, TReturn> This<T1, T2, T3, TReturn>(Func<T1, T2, T3, TReturn> func) => func;

        /// <summary>
        /// Returns <paramref name="func"/>. This method makes writing in a fluent style a little easier.
        /// </summary>
        public static Func<T1, T2, T3, T4, TReturn> This<T1, T2, T3, T4, TReturn>(Func<T1, T2, T3, T4, TReturn> func) => func;

        /// <summary>
        /// Projects the return value of a method into a new form.
        /// </summary>
        public static Func<TResult> Select<TSource, TResult>(this Func<TSource> source, Func<TSource, TResult> selector) =>
            () => selector(source());

        /// <summary>
        /// Projects the return value of a method into a new form by incorporating the index of the
        /// invocation.
        /// </summary>
        public static Func<TResult> Select<TSource, TResult>(this Func<TSource> source, Func<TSource, int, TResult> selector)
        {
            return source.AppendArg<int, TSource>().Select((s, i, _) => selector(s, i)).Bind(0);
        }

        /// <summary>
        /// Projects the return value of a method into a new form.
        /// </summary>
        public static Func<T1, TResult> Select<TSource, T1, TResult>(this Func<T1, TSource> source, Func<TSource, T1, TResult> selector) =>
            source.Select((s, i, arg) => selector(s, arg));

        /// <summary>
        /// Projects the return value of a method into a new form.
        /// </summary>
        public static Func<T1, TResult> Select<TSource, T1, TResult>(this Func<T1, TSource> source, Func<TSource, TResult> selector) =>
            source.Select((s, i, arg) => selector(s));

        /// <summary>
        /// Projects the return value of a method into a new form by incorporating the index of the
        /// invocation.
        /// </summary>
        public static Func<T1, TResult> Select<TSource, T1, TResult>(this Func<T1, TSource> source, Func<TSource, int, T1, TResult> selector)
        {
            var index = 0;
            return param =>
            {
                var result = selector(source(param), index, param);
                index++;
                return result;
            };
        }

        /// <summary>
        /// Combines two methods into one method that returns the results of the two as a
        /// <see cref="Tuple{T1, T2}"/>.
        /// </summary>
        public static Func<Tuple<TReturn1, TReturn2>> TupleJoin<TReturn1, TReturn2>(Func<TReturn1> func1, Func<TReturn2> func2) =>
            () => Tuple.Create(func1(), func2());

        /// <summary>
        /// Combines two methods into one method that returns the results of the two as a
        /// <see cref="Tuple{T1, T2}"/>.
        /// </summary>
        public static Func<IEnumerable<T>> Join<T>(params Func<T>[] funcs) => () => funcs.Select(f => f());

        /// <summary>
        /// Returns a method that invokes the <paramref name="listener"/> methods
        /// whenever <paramref name="function"/> is invoked.
        /// </summary>
        public static Func<T1, T2, T3, T4, TResult> Listen<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> function, Action<TResult> listener)
        {
            return (arg1, arg2, arg3, arg4) =>
            {
                var result = function(arg1, arg2, arg3, arg4);
                listener(result);
                return result;
            };
        }

        /// <summary>
        /// Returns a method that invokes the <paramref name="listener"/> methods
        /// whenever <paramref name="function"/> is invoked.
        /// </summary>
        public static Func<T1, T2, T3, TResult> Listen<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> function, Action<TResult> listener) =>
            function.AppendArg<T1, T2, T3, int, TResult>().Listen(listener).BindArg4(0);

        /// <summary>
        /// Returns a method that invokes the <paramref name="listener"/> methods
        /// whenever <paramref name="function"/> is invoked.
        /// </summary>
        public static Func<T1, T2, TResult> Listen<T1, T2, TResult>(this Func<T1, T2, TResult> function, Action<TResult> listener) =>
            function.AppendArg<T1, T2, int, TResult>().Listen(listener).BindArg3(0);

        /// <summary>
        /// Returns a method that invokes the <paramref name="listener"/> methods
        /// whenever <paramref name="function"/> is invoked.
        /// </summary>
        public static Func<T1, TResult> Listen<T1, TResult>(this Func<T1, TResult> function, Action<TResult> listener) =>
            function.AppendArg<T1, int, TResult>().Listen(listener).BindArg2(0);

        /// <summary>
        /// Returns a method that invokes the <paramref name="listener"/> methods
        /// whenever <paramref name="function"/> is invoked.
        /// </summary>
        public static Func<TResult> Listen<TResult>(this Func<TResult> function, Action<TResult> listener) =>
            function.AppendArg<int, TResult>().Listen(listener).Bind(0);

        /// <summary>
        /// Creates a method that, when invoked, creates a new <typeparamref name="T"/> using the
        /// default constructor.
        /// </summary>
        public static Func<T> Default<T>() where T : new() => () => new T();

        /// <summary>
        /// Creates a method that, when invoked, creates a new <typeparamref name="TConcrete"/> using the
        /// default constructor.
        /// </summary>
        public static Func<TInterface> Default<TConcrete, TInterface>()
            where TConcrete : TInterface, new() => () => new TConcrete();

        /// <summary>
        /// Creates a function that returns the value specified.
        /// </summary>
        public static Func<T> StaticFactory<T>(this T value) => () => value;

        /// <summary>
        /// Returns a method whose return value goes up each time it is invoked. This method is
        /// thread safe.
        /// </summary>
        public static Func<int> Counter()
        {
            var index = 0;
            return () => Interlocked.Increment(ref index);
        }

        /// <summary>
        /// Returns a method that, when invoked, calls <paramref name="method"/> passing in the
        /// return value of <paramref name="arg1"/>.
        /// </summary>
        public static Func<TResult> Bind<T1, TResult>(this Func<T1, TResult> method, Arg<T1> arg1) =>
            () => method(arg1.Func());

        /// <summary>
        /// Binds a method to the arg that projects it into a new form.
        /// </summary>
        public static Func<T1, TResult> Bind<T1, TResult>(this Func<T1, TResult> func, Func<T1, T1> selector) =>
            arg1 => func(selector(arg1));

        /// <summary>
        /// Returns a method that, when invoked, calls <paramref name="method"/> passing in the
        /// return value of <paramref name="arg1"/> and <paramref name="arg2"/>.
        /// </summary>
        public static Func<TResult> Bind<T1, T2, TResult>(this Func<T1, T2, TResult> method, Arg<T1> arg1, Arg<T2> arg2) =>
            () => method(arg1.Func(), arg2.Func());

        /// <summary>
        /// Returns a method that, when invoked, calls <paramref name="method"/> with
        /// <paramref name="arg1"/> as its first argument.
        /// </summary>
        public static Func<T2, TResult> BindArg1<T1, T2, TResult>(this Func<T1, T2, TResult> method, Arg<T1> arg1) =>
            arg2 => method(arg1.Func(), arg2);

        /// <summary>
        /// Returns a method that, when invoked, calls <paramref name="method"/> with
        /// <paramref name="arg2"/> as its second argument.
        /// </summary>
        public static Func<T1, TResult> BindArg2<T1, T2, TResult>(this Func<T1, T2, TResult> method, Arg<T2> arg2) =>
            arg1 => method(arg1, arg2.Func());

        /// <summary>
        /// Returns a method that, when invoked, calls <paramref name="method"/> passing in the
        /// return value of <paramref name="arg1"/>, <paramref name="arg2"/>, and <paramref name="arg3"/>.
        /// </summary>
        public static Func<TResult> Bind<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> method, Arg<T1> arg1, Arg<T2> arg2, Arg<T3> arg3) =>
            () => method(arg1.Func(), arg2.Func(), arg3.Func());

        /// <summary>
        /// Returns a method that, when invoked, calls <paramref name="method"/> with
        /// <paramref name="arg1"/> as its second argument.
        /// </summary>
        public static Func<T2, T3, TResult> BindArg1<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> method, Arg<T1> arg1) =>
            (arg2, arg3) => method(arg1.Func(), arg2, arg3);

        /// <summary>
        /// Returns a method that, when invoked, calls <paramref name="method"/> with
        /// <paramref name="arg2"/> as its second argument.
        /// </summary>
        public static Func<T1, T3, TResult> BindArg2<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> method, Arg<T2> arg2) =>
            (arg1, arg3) => method(arg1, arg2.Func(), arg3);

        /// <summary>
        /// Returns a method that, when invoked, calls <paramref name="method"/> with
        /// <paramref name="arg3"/> as its second argument.
        /// </summary>
        public static Func<T1, T2, TResult> BindArg3<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> method, Arg<T3> arg3) =>
            (arg1, arg2) => method(arg1, arg2, arg3.Func());

        /// <summary>
        /// Returns a method that, when invoked, calls <paramref name="method"/> passing in the
        /// return value of <paramref name="arg1"/>, <paramref name="arg2"/>, and <paramref name="arg3"/>.
        /// </summary>
        public static Func<TResult> Bind<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> method, Arg<T1> arg1, Arg<T2> arg2, Arg<T3> arg3, Arg<T4> arg4) =>
            () => method(arg1.Func(), arg2.Func(), arg3.Func(), arg4.Func());

        /// <summary>
        /// Returns a method that, when invoked, calls <paramref name="method"/> with
        /// <paramref name="arg1"/> as its second argument.
        /// </summary>
        public static Func<T2, T3, T4, TResult> BindArg1<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> method, Arg<T1> arg1) =>
            (arg2, arg3, arg4) => method(arg1.Func(), arg2, arg3, arg4);

        /// <summary>
        /// Returns a method that, when invoked, calls <paramref name="method"/> with
        /// <paramref name="arg2"/> as its second argument.
        /// </summary>
        public static Func<T1, T3, T4, TResult> BindArg2<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> method, Arg<T2> arg2) =>
            (arg1, arg3, arg4) => method(arg1, arg2.Func(), arg3, arg4);

        /// <summary>
        /// Returns a method that, when invoked, calls <paramref name="method"/> with
        /// <paramref name="arg3"/> as its second argument.
        /// </summary>
        public static Func<T1, T2, T4, TResult> BindArg3<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> method, Arg<T3> arg3) =>
            (arg1, arg2, arg4) => method(arg1, arg2, arg3.Func(), arg4);

        /// <summary>
        /// Returns a method that, when invoked, calls <paramref name="method"/> with
        /// <paramref name="arg4"/> as its second argument.
        /// </summary>
        public static Func<T1, T2, T3, TResult> BindArg4<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> method, Arg<T4> arg4) =>
            (arg1, arg2, arg3) => method(arg1, arg2, arg3, arg4.Func());

        /// <summary>
        /// Returns a method that, when invoked, calls <paramref name="method"/> passing in the
        /// return value of <paramref name="arg1"/>, <paramref name="arg2"/>, and <paramref name="arg3"/>.
        /// </summary>
        public static Func<TResult> Bind<T1, T2, T3, T4, T5, TResult>(this Func<T1, T2, T3, T4, T5, TResult> method, Arg<T1> arg1, Arg<T2> arg2, Arg<T3> arg3, Arg<T4> arg4, Arg<T5> arg5) =>
            () => method(arg1.Func(), arg2.Func(), arg3.Func(), arg4.Func(), arg5.Func());

        /// <summary>
        /// Returns a method that, when invoked, calls <paramref name="method"/> with
        /// <paramref name="arg1"/> as its second argument.
        /// </summary>
        public static Func<T2, T3, T4, T5, TResult> BindArg1<T1, T2, T3, T4, T5, TResult>(this Func<T1, T2, T3, T4, T5, TResult> method, Arg<T1> arg1) =>
            (arg2, arg3, arg4, arg5) => method(arg1.Func(), arg2, arg3, arg4, arg5);

        /// <summary>
        /// Returns a method that, when invoked, calls <paramref name="method"/> with
        /// <paramref name="arg2"/> as its second argument.
        /// </summary>
        public static Func<T1, T3, T4, T5, TResult> BindArg2<T1, T2, T3, T4, T5, TResult>(this Func<T1, T2, T3, T4, T5, TResult> method, Arg<T2> arg2) =>
            (arg1, arg3, arg4, arg5) => method(arg1, arg2.Func(), arg3, arg4, arg5);

        /// <summary>
        /// Returns a method that, when invoked, calls <paramref name="method"/> passing in the
        /// return value of <paramref name="arg1"/>, <paramref name="arg2"/>, and <paramref name="arg3"/>.
        /// </summary>
        public static Func<TResult> Bind<T1, T2, T3, T4, T5, T6, TResult>(
            this Func<T1, T2, T3, T4, T5, T6, TResult> method, Arg<T1> arg1, Arg<T2> arg2, Arg<T3> arg3, Arg<T4> arg4, Arg<T5> arg5, Arg<T6> arg6) =>
            () => method(arg1.Func(), arg2.Func(), arg3.Func(), arg4.Func(), arg5.Func(), arg6.Func());

        /// <summary>
        /// Returns a method that, when invoked, calls <paramref name="method"/> with
        /// <paramref name="arg2"/> as its second argument.
        /// </summary>
        public static Func<T1, T3, T4, T5, T6, TResult> BindArg2<T1, T2, T3, T4, T5, T6, TResult>(this Func<T1, T2, T3, T4, T5, T6, TResult> method, Arg<T2> arg2) =>
            (arg1, arg3, arg4, arg5, arg6) => method(arg1, arg2.Func(), arg3, arg4, arg5, arg6);

        /// <summary>
        /// Returns a method that, when invoked, calls <paramref name="method"/> with
        /// <paramref name="arg2"/> as its second argument.
        /// </summary>
        public static Func<T1, T3, T4, T5, T6, T7, TResult> BindArg2<T1, T2, T3, T4, T5, T6, T7, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, TResult> method, Arg<T2> arg2) =>
            (arg1, arg3, arg4, arg5, arg6, arg7) => method(arg1, arg2.Func(), arg3, arg4, arg5, arg6, arg7);

        /// <summary>
        /// Converts the method provided into a method which takes one, ignored, argument.
        /// </summary>
        public static Func<T1, TResult> AppendArg<T1, TResult>(this Func<TResult> method) => _ => method();

        /// <summary>
        /// Converts the method provided into a method which takes one, ignored, argument.
        /// </summary>
        public static Func<T1, T2, TResult> AppendArg<T1, T2, TResult>(this Func<T1, TResult> method) =>
            (arg1, _) => method(arg1);

        /// <summary>
        /// Converts the method provided into a method which takes one, ignored, argument.
        /// </summary>
        public static Func<T1, T2, T3, TResult> AppendArg<T1, T2, T3, TResult>(this Func<T1, T2, TResult> method) =>
            (arg1, arg2, _) => method(arg1, arg2);

        /// <summary>
        /// Converts the method provided into a method which takes one, ignored, argument.
        /// </summary>
        public static Func<T1, T2, T3, T4, TResult> AppendArg<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, TResult> method) =>
            (arg1, arg2, arg3, _) => method(arg1, arg2, arg3);

        /// <summary>
        /// Converts the method provided into a method which takes one, ignored, argument.
        /// </summary>
        public static Func<T1, T2, TResult> PrependArg<T1, T2, TResult>(this Func<T2, TResult> method) =>
            (arg1, arg2) => method(arg2);

        /// <summary>
        /// Applies a projection to the second argument.
        /// </summary>
        public static Func<T1, T2, TResult> SelectArg2<T1, T2, T2Result, TResult>(
            this Func<T1, T2Result, TResult> func, Func<T2, T2Result> selector) =>
            (arg1, arg2) => func(arg1, selector(arg2));

        /// <summary>
        /// Applies a projection to the second argument.
        /// </summary>
        public static Func<T1, T2, T3, TResult> SelectArg3<T1, T2, T3, T3Result, TResult>(
            this Func<T1, T2, T3Result, TResult> func, Func<T3, T3Result> selector) =>
            (arg1, arg2, arg3) => func(arg1, arg2, selector(arg3));

        /// <summary>
        /// A <see cref="Func{T, TResult}"/> that returns the same value it was given.
        /// </summary>
        public static Func<T, T> Passthrough<T>() => value => value;

        /// <summary>
        /// Generates a list of items from the provided method. The returned <see cref="IEnumerable{T}"/>
        /// will produce values infinitely. Use <see cref="Enumerable.Take{T}"/> to restrict
        /// this.
        /// </summary>
        /// <param name="method">The method that produces a wave.</param>
        /// <returns>The items generated from the <paramref name="method"/>.</returns>
        public static IEnumerable<T> AsEnumerable<T>(this Func<T> method)
        {
            while (true) yield return method();
            // ReSharper disable IteratorNeverReturns
        }
        // ReSharper restore IteratorNeverReturns

        /// <summary>
        /// Returns a <see cref="Func{T1, TResult}"/> as an <see cref="Action{T1}"/>.
        /// </summary>
        public static Action AsAction<TResult>(this Func<TResult> func) => () => func();

        /// <summary>
        /// Returns a <see cref="Func{T1, TResult}"/> as an <see cref="Action{T1}"/>.
        /// </summary>
        public static Action<T1> AsAction<T1, TResult>(this Func<T1, TResult> func) => arg1 => func(arg1);

        /// <summary>
        /// Returns a <see cref="Func{T1, TResult}"/> as an <see cref="Action{T1}"/>.
        /// </summary>
        public static Action<T1, T2> AsAction<T1, T2, TResult>(this Func<T1, T2, TResult> func) =>
            (arg1, arg2) => func(arg1, arg2);

        /// <summary>
        /// Performs an upcast from <typeparamref name="TSource"/> to <typeparamref name="TReturn"/>.
        /// </summary>
        public static Func<TReturn> Upcast<TSource, TReturn>(this Func<TSource> func) where TSource : TReturn =>
            func.Select<TSource, TReturn>(v => v);

        /// <summary>
        /// Returns the <see cref="IEnumerable{T}"/> within the <see cref="Func{T}"/> without
        /// invoking the <see cref="Func{TResult}"/> until necessary.
        /// </summary>
        public static IEnumerable<T> Switch<T>(this Func<IEnumerable<T>> method)
        {
            foreach (var v in method()) yield return v;
        }

        /// <summary>
        /// Creates a method that replaces the value produced by <paramref name="method"/> with
        /// the value produced by <paramref name="replacer"/> with <paramref name="distance"/>
        /// between each replacement.
        /// </summary>
        /// <param name="method">The method whose return value is to be replaced.</param>
        /// <param name="distance">The amount of space to put between each value being replaced.</param>
        /// <param name="replacer">The method whose return value is to do the replacing.</param>
        public static Func<TResult> SkipReplace<TResult>(this Func<TResult> method, int distance, Func<TResult> replacer) =>
            method.AppendArg<int, TResult>().SkipReplace(distance, _ => replacer()).Bind(0);

        /// <summary>
        /// Creates a method that replaces the value produced by <paramref name="method"/> with
        /// the value produced by <paramref name="replacer"/> with <paramref name="distance"/>
        /// between each replacement.
        /// </summary>
        /// <param name="method">The method whose return value is to be replaced.</param>
        /// <param name="distance">The amount of space to put between each value being replaced.</param>
        /// <param name="replacer">The method whose return value is to do the replacing.</param>
        public static Func<T1, TResult> SkipReplace<T1, TResult>(this Func<T1, TResult> method, int distance, Func<T1, TResult> replacer)
        {
            distance.Throw(nameof(distance)).IfLessThan(0);

            // We add one to index so that zero doesn't get included.
            return method.Replace((param, index) => (index + 1) % distance == 0, replacer);
        }

        /// <summary>
        /// Creates a method that replaces the value produced by <paramref name="method"/> with
        /// the value produced by <paramref name="replacer"/> when dictated by <paramref name="predicate"/>.
        /// </summary>
        /// <param name="method">The method whose return value is to be replaced. This method is
        /// only invoked when <paramref name="predicate"/> returns false.</param>
        /// <param name="predicate">The method that determines when a value is to be replaced. The
        /// first parameter is the current invocation index starting from zero.</param>
        /// <param name="replacer">The method whose return value is to do the replacing. This method
        /// is only invoked when <paramref name="predicate"/> returns true.</param>
        public static Func<TResult> Replace<TResult>(this Func<TResult> method, Func<int, bool> predicate, Func<TResult> replacer) =>
            method.AppendArg<int, TResult>().Replace((_, index) => predicate(index), _ => replacer()).Bind(0);

        /// <summary>
        /// Creates a method that replaces the value produced by <paramref name="method"/> with
        /// the value produced by <paramref name="replacer"/> when dictated by <paramref name="predicate"/>.
        /// </summary>
        /// <param name="method">The method whose return value is to be replaced. This method is
        /// only invoked when <paramref name="predicate"/> returns false.</param>
        /// <param name="predicate">The method that determines when a value is to be replaced. The
        /// first parameter is the parameter passed to the returned method.</param>
        /// <param name="replacer">The method whose return value is to do the replacing. This method
        /// is only invoked when <paramref name="predicate"/> returns true.</param>
        public static Func<T1, TResult> Replace<T1, TResult>(this Func<T1, TResult> method, Func<T1, bool> predicate, Func<T1, TResult> replacer) =>
            method.Replace((param, _) => predicate(param), replacer);

        /// <summary>
        /// Creates a method that replaces the value produced by <paramref name="method"/> with
        /// the value produced by <paramref name="replacer"/> when dictated by <paramref name="predicate"/>.
        /// </summary>
        /// <param name="method">The method whose return value is to be replaced. This method is
        /// only invoked when <paramref name="predicate"/> returns false.</param>
        /// <param name="predicate">The method that determines when a value is to be replaced. The
        /// first parameter is the parameter passed to the returned method. The second parameter is
        /// the current invocation index starting from zero.</param>
        /// <param name="replacer">The method whose return value is to do the replacing. This method
        /// is only invoked when <paramref name="predicate"/> returns true.</param>
        public static Func<T1, TResult> Replace<T1, TResult>(this Func<T1, TResult> method, Func<T1, int, bool> predicate, Func<T1, TResult> replacer)
        {
            var index = 0;
            return param =>
            {
                var result = predicate(param, index) ? replacer(param) : method(param);
                index++;
                return result;
            };
        }

        /// <summary>Returns a method that negates the returned value of the method provided.</summary>
        public static Func<bool> Not(this Func<bool> func) => () => !func();

        /// <summary>Returns a method that negates the returned value of the method provided.</summary>
        public static Func<T1, bool> Not<T1>(this Func<T1, bool> func) => arg1 => !func(arg1);

        /// <summary>
        /// Returns a method that returns true if the value passed to it is null, false if otherwise.
        /// </summary>
        public static Func<T1, bool> NotNull<T1>() => arg1 => arg1 != null;

        /// <summary>
        /// Returns a predicate that returns true if the value provided to it is different from the
        /// the value provided on the last invocation. Used with methods like
        /// <see cref="ActionExt.Where{T}(Action{T}, Func{T, bool})"/>
        /// </summary>
        /// <param name="comparer">The instance to use for comparison. Uses
        /// <see cref="EqualityComparer{T}.Default"/> if nothing provided.</param>
        public static Func<T, bool> Changed<T>(IEqualityComparer<T> comparer = null) where T : IEquatable<T>
        {
            comparer = comparer ?? EqualityComparer<T>.Default;
            T previous = default;
            return current =>
            {
                if (comparer.Equals(previous, current) == false)
                {
                    previous = current;
                    return true;
                }

                return false;
            };
        }
    }
}