[Fork] Rx - BufferWhile with replaysubject | C# Online Compiler

[Fork] Rx - BufferWhile with replaysubject by OkkeHendriks

using System;
using System.Collections.Generic;
using System.Reactive.Disposables;
using System.Reactive.Linq;
using System.Linq;
using System.Reactive.Subjects;
using System.Threading.Tasks;
using Microsoft.Reactive.Testing;

using System.Runtime.Serialization;

public class Program
{
	public void Main()
	{
		var src = new ReplaySubject<int>();
		src.OnNext(1);
		src.OnNext(2);
		src.OnNext(3);
		var srcBuffered = ObservableExtensions.BufferWhile(src, (value, eventValue) => true, TimeSpan.FromMilliseconds(10), 1, false);
		src.OnNext(4);
		src.OnNext(5);
		src.OnNext(6);
		
		src.Subscribe(e => Console.WriteLine("Src: " + e));
		srcBuffered.Subscribe(e => {
			var i = 0;
			foreach(var e2 in e)
			{
				i++;
				Console.WriteLine("SrcBuffered: (" + i + ") " + e2);
			}
		});
		srcBuffered.Subscribe(e => {
			var i = 0;
			foreach(var e2 in e)
			{
				i++;
				Console.WriteLine("SrcBuffered2: (" + i + ") " + e2);
			}
		});
		srcBuffered.Subscribe(e => {
			var i = 0;
			foreach(var e2 in e)
			{
				i++;
				Console.WriteLine("SrcBuffered3: (" + i + ") " + e2);
			}
		});
	}
	
	 /// <summary>
    /// Contains extension methods for <see cref="Observable"/>.
    /// </summary>
    public static class ObservableExtensions
    {

        /// <summary>
        /// Buffers an observable stream while a specified condition holds.
        /// <para>The buffer will be extended while either <paramref name="continueComparer"/> returns false when
        /// applied on the last two events. This is overridden by the timeout, determined by <paramref name="timeout"/>,
        /// when this timeout occurs, the buffer is flushed regardless of the result of
        /// <paramref name="continueComparer"/>.
        /// The buffer is also flushed if <paramref name=" maxsize"/> is reached.
        /// Empty batches are removed.
        /// </para>
        /// </summary>
        /// <typeparam name="T">The element type of the observable to buffer.</typeparam>
        /// <param name="observable">The observable to buffer.</param>
        /// <param name="continueComparer">A function that compares the last two elements in the stream, and returns a
        /// value indicating whether the buffer should be extended or flushed.</param>
        /// <param name="timeout">A timeout after which to flush the buffer, regardless
        /// <paramref name="continueComparer"/>.</param>
        /// <param name="maxsize">The maximum amount of elements in the buffer. </param>
        /// <param name="sliding">Indicates whether the timeout should be sliding or not. If the timeout is sliding,
        /// every received event will reset the timeout, otherwise, it will only be reset after every buffer flush.
        /// </param>
        /// <returns>The resulting observable sequence of buffers, without empty batches.</returns>
        public static IObservable<IList<T>> BufferWhile<T>(
                    IObservable<T> observable,
                    Func<T, T, bool> continueComparer,
                    TimeSpan timeout,
                    int maxsize = int.MaxValue,
                    bool sliding = true)
        {


            /* The previous value that was processed by the compare method. This value is compared to the current value
             * in order to determine whether the current value should be included in the batch. */
            var lastValue = Prodrive.Maybe<T>.None;
            /* Due to timing issues, the first trigger on the timer might not actually be processed by the timer
             * observable. Through this variable, the observable indicates that it has been triggered. If it is not set
             * to true, the comparer will unconditionally trigger it again, so as to initialize the timer. */
            var timerTicked = false;

            /* Keeps track of the count. If it exceeds maxsize, a tick is created. */
            int count = 0;

            /*
             * Boundaries are used in the buffer method. They are observables that produce a value when the buffer
             * method should stop buffering; send out its current buffer and start a new one. The boundaries are
             * generated by the boundaries observable, which is a combination of the following two sub-observables:
             *
             * - comparerTick is triggered every time the continue comparer returns false, i.e. it tells us to sop the
             * buffer and start a new one.
             *
             * - timerTick is triggered every time the timer is triggered. This timer is then throttled, which will only
             * produce a value if it is triggered first, and then not triggered for the specified time. This allows for
             * a sliding timeout, by continually triggering the timer, delaying the trigger.
             */
            var comparerTick = new Subject<int>();
            var timerTick = new Subject<int>();
            var countTick = new Subject<int>();
            var throttledTimer = timerTick.Do(x => timerTicked = true).Throttle(timeout);
            var boundaries = comparerTick.Merge(throttledTimer).Merge(countTick);

            /*
             * This action determines whether a boundary should be triggered.
             *
             * It is responsible for triggering the timer observable if it has not been before, or every time if the
             * timeout is sliding.
             *
             * Secondly it runs the comparer between the current value and the previous value, if this comparer returns
             * false, the comparer observable
             */
            Action<T> produceBoundaries =
                value =>
                {
                    // With a sliding expiration, we only want to propagate if no event came for the specified time at
                    // all. This is achieved by sending a trigger to it on every input.
                    if (!timerTicked || sliding)
                        timerTick.OnNext(1);

                    if (lastValue.Match(x => !continueComparer(x, value), () => false))
                        comparerTick.OnNext(1);

                    if (count >= maxsize)
                        countTick.OnNext(1);

                    lastValue = value;
                    count++;
                };

            /*
             * This action resets the timer. By setting timerTicked to false, the next comparison will trigger the timer
             * observable again.
             */
            Action<IList<T>> resetTimer = list => timerTicked = false;
            Action<IList<T>> resetCount = list => count = 0;

            /*
             * The main flow of this function is:
             *
             * For each value produced by the observable:
             * - Call produceBoundaries to determine whether the timer or the comparer should be triggered.
             * - Call buffer on the boundaries. Because this all happens in the same thread, boundaries generated in the
             * previous step will trigger a buffer reset before the current value reaches this buffer. The current value
             * will therefore be the first element of the next buffer.
             * - Whenever the buffer is reset, and is sent on, the timer is reset.
             * - Filter out the empty buffers.
             */
            return observable
                .Do(produceBoundaries)
                .Buffer(boundaries)
                .Do(resetTimer)
                .Do(resetCount)
                .Where(x => x.Any());
        }
    }
}


// Decompiled with JetBrains decompiler
// Type: Prodrive.Maybe`1
// Assembly: Prodrive.Core, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
// MVID: 2A15C284-4230-4980-9AAD-583D09C6D7A9
// Assembly location: C:\git\manufacturing-data-collection-facade\ManufacturingDataCollectionFacade\packages\Prodrive.Core.1.3.0\lib\netstandard2.0\Prodrive.Core.dll


namespace Prodrive
{
  /// <summary>
  /// Represents a value of the underlying type or absence thereof. Allows to avoid <c>null</c>-based representation
  /// of values being undefined, absent, unknown, etc. Supports 'pattern' matching and combination of multiple
  /// <c>Maybe</c> values in one expression.
  /// </summary>
  /// <remarks>
  /// <para>
  /// Conceptually, values of type <c>Maybe</c> can have two shapes: <c>Some(v)</c> and <c>None</c>, where <c>v</c> is
  /// a value of the underlying, "wrapped" type. While this implementation does not contain these
  /// constructors explicitly, the documentation refers to <c>Maybe</c> values in terms of <c>Some</c> and
  /// <c>None</c>.
  /// </para>
  /// <para>
  /// Values of this class are immutable.
  /// </para>
  /// </remarks>
  /// <typeparam name="T">The underlying 'actual' type.</typeparam>
  public struct Maybe<T> : IEquatable<Maybe<T>>
  {
    /// <summary>
    /// The value wrapped by this <c>Maybe</c> value, if it is a <c>Some</c>.
    /// </summary>
    private readonly T value;
    /// <summary>
    /// Implements differentiation between the logical values of this type: Some and None.
    /// </summary>
    private readonly bool isSome;

    /// <summary>
    /// Initializes a new instance of the <see cref="T:Prodrive.Maybe`1" /> struct.
    /// If the given underlying value is <c>null</c>, initializes a
    /// <c>None</c>, otherwise a <c>Some</c>.
    /// </summary>
    /// <param name="value">
    /// The underlying value, may be <c>null</c>.
    /// </param>
    public Maybe(T value)
      : this()
    {
      this.value = value;
      this.isSome = (object) value != null;
    }

    /// <summary>
    /// Gets a <c>None</c> value. Essentially serves as a constructor.
    /// </summary>
    public static Maybe<T> None
    {
      get
      {
        return new Maybe<T>();
      }
    }

    /// <summary>
    /// Gets a value indicating whether the value represented by this <c>Maybe</c> value is present.
    /// </summary>
    public bool IsSome
    {
      get
      {
        return this.isSome;
      }
    }

    /// <summary>
    /// Gets a value indicating whether the value represented by this <c>Maybe</c> value is not present.
    /// </summary>
    public bool IsNone
    {
      get
      {
        return !this.isSome;
      }
    }

    /// <summary>
    /// Gets the value represented by this <c>Maybe</c> value, if and only if it is present. This property should
    /// not be evaluated without a guarding check using <see cref="P:Prodrive.Maybe`1.IsSome" /> or <see cref="P:Prodrive.Maybe`1.IsNone" />.
    /// </summary>
    public T Value
    {
      get
      {
        if (this.isSome)
          return this.value;
        throw new InvalidOperationException("Attempted to retrieve the value of None.");
      }
    }

    /// <summary>
    /// Converts a value to its <c>Maybe</c> representation. <c>null</c>-values are converted to <c>None</c>,
    /// non-<c>null</c> values to <c>Some</c>. This conversion operator allows to seamlessly use 'plain' values in
    /// expressions involving <c>Maybe</c>.
    /// </summary>
    /// <param name="value">
    /// A value to convert to <c>Maybe</c>.
    /// </param>
    /// <returns>
    /// <c>None</c> if <paramref name="value" /> is <c>null</c>, otherwise <c>Some(value)</c>.
    /// </returns>
    public static implicit operator Maybe<T>(T value)
    {
      return Maybe<T>.EliminateNull(value);
    }

    /// <summary>Determines whether two Maybe values are equal.</summary>
    /// <param name="i1">The first Maybe value.</param>
    /// <param name="i2">The second Maybe value.</param>
    /// <returns>
    /// <c>true</c> if the specified <c>i1.Equals(i2)</c> holds, otherwise <c>false</c>.
    /// </returns>
    public static bool operator ==(Maybe<T> i1, Maybe<T> i2)
    {
      return i1.Equals(i2);
    }

    /// <summary>Determines whether two Maybe value are not equal.</summary>
    /// <param name="i1">The first Maybe value.</param>
    /// <param name="i2">The second Maybe value.</param>
    /// <returns>
    /// <c>true</c> if the specified <c>i1.Equals(i2)</c> does not hold, otherwise <c>false</c>.
    /// </returns>
    public static bool operator !=(Maybe<T> i1, Maybe<T> i2)
    {
      return !i1.Equals(i2);
    }

    /// <summary>
    /// Matches against this <c>Maybe</c> value and performs different actions for <c>Some</c> and <c>None</c>.
    /// </summary>
    /// <param name="some">
    /// The action to be performed when this value is <c>Some(v)</c>. The wrapped value <c>v</c> is passed to the
    /// action.
    /// </param>
    /// <param name="none">
    /// The action to be performed when this value is <c>None</c>.
    /// </param>
    public void Match(Action<T> some, Action none)
    {
      if (this.isSome)
        some(this.Value);
      else
        none();
    }

    public U Match<U>(Func<T, U> some, Func<U> none)
    {
      return !this.isSome ? none() : some(this.Value);
    }

    public U Match<U>(Func<T, U> some, U none)
    {
      return !this.isSome ? none : some(this.Value);
    }

    public Maybe<U> Bind<U>(Func<T, Maybe<U>> func)
    {
      return !this.isSome ? Maybe<U>.None : func(this.Value);
    }

    /// <summary>
    /// Applies the given accumulator function over this value.
    /// </summary>
    /// <remarks>
    /// This function is sometimes called <c>Aggregate</c>, for example as an extension method on
    /// <c>IEnumerable{T}</c>.
    /// </remarks>
    /// <typeparam name="U">The result type of accumulation.</typeparam>
    /// <param name="func">
    /// An accumulator function to be invoked on the wrapped value.
    /// </param>
    /// <param name="seed">
    /// The initial value to be passed to <paramref name="func" />.
    /// </param>
    /// <returns>
    /// <paramref name="func" /> applied to <c>(v,seed)</c> if this value is <c>Some(v)</c> or
    /// <paramref name="seed" /> when this value is <c>None</c>.
    /// </returns>
    public U Fold<U>(Func<T, U, U> func, U seed)
    {
      return !this.isSome ? seed : func(this.Value, seed);
    }

    /// <summary>
    /// Determines equivalence with another <c>Maybe</c> value. The properties of equivalence relation on
    /// <c>Maybe</c> are as follows:
    /// <ul>
    /// <li><c>None</c> is equal to <c>None</c></li>
    /// <li><c>Some(a)</c> is not equal to <c>None</c>, for any <c>a</c></li>
    /// <li><c>Some(a)</c> is equal to <c>Some(b)</c> if and only if <c>object.Equals(a,b)</c> is true</li>
    /// </ul>
    /// </summary>
    /// <param name="other">
    /// A <c>Maybe</c> value to compare with this value.
    /// </param>
    /// <returns>
    /// <c>true</c> if this <c>Maybe</c> value equals <paramref name="other" />, otherwise <c>false</c>.
    /// </returns>
    public bool Equals(Maybe<T> other)
    {
      if (this.isSome ^ other.isSome)
        return false;
      return this.IsNone && other.IsNone || object.Equals((object) this.Value, (object) other.Value);
    }

    /// <summary>Determines equivalence with another object.</summary>
    /// <param name="obj">The object to compare with the current object.</param>
    /// <returns>
    /// <c>true</c> if and only if this value is equal to <paramref name="obj" />.
    /// </returns>
    public override bool Equals(object obj)
    {
		if(!(obj is Maybe<T>))
			return false;
	  var other = (Maybe<T>)obj;
      return this.Equals(other);
    }

    /// <summary>
    /// Returns the hash code of this <c>Maybe</c> value.
    /// </summary>
    /// <returns>
    /// Hash code of <c>v</c> if this value is <c>Some(v)</c>, otherwise <c>0</c>.
    /// </returns>
    public override int GetHashCode()
    {
      return !this.isSome ? 0 : this.value.GetHashCode();
    }

    /// <summary>
    /// Returns the fully qualified type name of this instance.
    /// </summary>
    /// <returns>
    /// A <see cref="T:System.String" /> containing a fully qualified type name.
    /// </returns>
    /// <filterpriority>2</filterpriority>
    public override string ToString()
    {
      return !this.isSome ? string.Format("None<{0}>", (object) typeof (T).Name) : string.Format("Some<{0}> {1}", (object) typeof (T).Name, (object) this.value);
    }

    public Maybe<T> Where(Func<T, bool> predicate)
    {
      return (this.isSome ? (predicate(this.value) ? 1 : 0) : 0) != 0 ? new Maybe<T>(this.value) : Maybe<T>.None;
    }

    public Maybe<U> Select<U>(Func<T, U> selector)
    {
      return !this.isSome ? Maybe<U>.None : new Maybe<U>(selector(this.value));
    }

    public Maybe<V> SelectMany<U, V>(Func<T, Maybe<U>> selector, Func<T, U, V> resultSelector)
    {
      if (!this.isSome)
        return Maybe<V>.None;
      T obj = this.value;
      Maybe<U> maybe = selector(obj);
      return !maybe.isSome ? Maybe<V>.None : new Maybe<V>(resultSelector(obj, maybe.value));
    }

    /// <summary>
    /// Wraps this <see cref="T:Prodrive.Maybe`1" /> in an <see cref="T:System.Collections.Generic.IEnumerable`1" />.
    /// </summary>
    /// <returns>
    /// Returns this <see cref="T:Prodrive.Maybe`1" /> wrapped in an <see cref="T:System.Collections.Generic.IEnumerable`1" />.
    /// </returns>
    public IEnumerable<T> AsEnumerable()
    {
      if (this.isSome)
        yield return this.value;
    }

    /// <summary>
    /// Wraps the given value in <c>None</c> if it is <c>null</c>, otherwise in <c>Some</c>.
    /// </summary>
    /// <param name="value">
    /// A value, may be <c>null</c>.
    /// </param>
    /// <returns>
    /// The <c>Maybe</c> representation of <paramref name="value" />.
    /// </returns>
    internal static Maybe<T> EliminateNull(T value)
    {
      return (object) value == null ? Maybe<T>.None : new Maybe<T>(value);
    }
  }
}

​x
 
using System;
using System.Collections.Generic;
using System.Reactive.Disposables;
using System.Reactive.Linq;
using System.Linq;
using System.Reactive.Subjects;
using System.Threading.Tasks;
using Microsoft.Reactive.Testing;
​
using System.Runtime.Serialization;
​
public class Program
{
    public void Main()
    {
        var src = new ReplaySubject<int>();
        src.OnNext(1);
        src.OnNext(2);
        src.OnNext(3);
        var srcBuffered = ObservableExtensions.BufferWhile(src, (value, eventValue) => true, TimeSpan.FromMilliseconds(10), 1, false);
        src.OnNext(4);
        src.OnNext(5);
        src.OnNext(6);
        
        src.Subscribe(e => Console.WriteLine("Src: " + e));
        srcBuffered.Subscribe(e => {
            var i = 0;
            foreach(var e2 in e)
            {
                i++;
                Console.WriteLine("SrcBuffered: (" + i + ") " + e2);
            }
        });
        srcBuffered.Subscribe(e => {
            var i = 0;
            foreach(var e2 in e)
            {
                i++;
                Console.WriteLine("SrcBuffered2: (" + i + ") " + e2);
            }
        });
        srcBuffered.Subscribe(e => {
            var i = 0;
            foreach(var e2 in e)
            {
                i++;
                Console.WriteLine("SrcBuffered3: (" + i + ") " + e2);
            }
        });
    }
    
     /// <summary>
    /// Contains extension methods for <see cref="Observable"/>.
    /// </summary>
    public static class ObservableExtensions
    {
​
        /// <summary>
        /// Buffers an observable stream while a specified condition holds.
        /// <para>The buffer will be extended while either <paramref name="continueComparer"/> returns false when
        /// applied on the last two events. This is overridden by the timeout, determined by <paramref name="timeout"/>,
        /// when this timeout occurs, the buffer is flushed regardless of the result of
        /// <paramref name="continueComparer"/>.
        /// The buffer is also flushed if <paramref name=" maxsize"/> is reached.
        /// Empty batches are removed.
        /// </para>
        /// </summary>
        /// <typeparam name="T">The element type of the observable to buffer.</typeparam>
        /// <param name="observable">The observable to buffer.</param>
        /// <param name="continueComparer">A function that compares the last two elements in the stream, and returns a
        /// value indicating whether the buffer should be extended or flushed.</param>
        /// <param name="timeout">A timeout after which to flush the buffer, regardless
        /// <paramref name="continueComparer"/>.</param>
        /// <param name="maxsize">The maximum amount of elements in the buffer. </param>
        /// <param name="sliding">Indicates whether the timeout should be sliding or not. If the timeout is sliding,
        /// every received event will reset the timeout, otherwise, it will only be reset after every buffer flush.
        /// </param>
        /// <returns>The resulting observable sequence of buffers, without empty batches.</returns>
        public static IObservable<IList<T>> BufferWhile<T>(
                    IObservable<T> observable,
                    Func<T, T, bool> continueComparer,
                    TimeSpan timeout,
                    int maxsize = int.MaxValue,
                    bool sliding = true)
        {
​
​
            /* The previous value that was processed by the compare method. This value is compared to the current value
             * in order to determine whether the current value should be included in the batch. */
            var lastValue = Prodrive.Maybe<T>.None;
            /* Due to timing issues, the first trigger on the timer might not actually be processed by the timer
             * observable. Through this variable, the observable indicates that it has been triggered. If it is not set
             * to true, the comparer will unconditionally trigger it again, so as to initialize the timer. */
            var timerTicked = false;
​
            /* Keeps track of the count. If it exceeds maxsize, a tick is created. */
            int count = 0;
​
            /*
             * Boundaries are used in the buffer method. They are observables that produce a value when the buffer
             * method should stop buffering; send out its current buffer and start a new one. The boundaries are
             * generated by the boundaries observable, which is a combination of the following two sub-observables:
             *
             * - comparerTick is triggered every time the continue comparer returns false, i.e. it tells us to sop the
             * buffer and start a new one.
             *
             * - timerTick is triggered every time the timer is triggered. This timer is then throttled, which will only
             * produce a value if it is triggered first, and then not triggered for the specified time. This allows for
             * a sliding timeout, by continually triggering the timer, delaying the trigger.
             */
            var comparerTick = new Subject<int>();
            var timerTick = new Subject<int>();
            var countTick = new Subject<int>();
            var throttledTimer = timerTick.Do(x => timerTicked = true).Throttle(timeout);
            var boundaries = comparerTick.Merge(throttledTimer).Merge(countTick);
​
            /*
             * This action determines whether a boundary should be triggered.
             *
             * It is responsible for triggering the timer observable if it has not been before, or every time if the
             * timeout is sliding.
             *
             * Secondly it runs the comparer between the current value and the previous value, if this comparer returns
             * false, the comparer observable
             */
            Action<T> produceBoundaries =
                value =>
                {
                    // With a sliding expiration, we only want to propagate if no event came for the specified time at
                    // all. This is achieved by sending a trigger to it on every input.
                    if (!timerTicked || sliding)
                        timerTick.OnNext(1);
​
                    if (lastValue.Match(x => !continueComparer(x, value), () => false))
                        comparerTick.OnNext(1);
​
                    if (count >= maxsize)
                        countTick.OnNext(1);
​
                    lastValue = value;
                    count++;
                };
​
            /*
             * This action resets the timer. By setting timerTicked to false, the next comparison will trigger the timer
             * observable again.
             */
            Action<IList<T>> resetTimer = list => timerTicked = false;
            Action<IList<T>> resetCount = list => count = 0;
​
            /*
             * The main flow of this function is:
             *
             * For each value produced by the observable:
             * - Call produceBoundaries to determine whether the timer or the comparer should be triggered.
             * - Call buffer on the boundaries. Because this all happens in the same thread, boundaries generated in the
             * previous step will trigger a buffer reset before the current value reaches this buffer. The current value
             * will therefore be the first element of the next buffer.
             * - Whenever the buffer is reset, and is sent on, the timer is reset.
             * - Filter out the empty buffers.
             */
            return observable
                .Do(produceBoundaries)
                .Buffer(boundaries)
                .Do(resetTimer)
                .Do(resetCount)
                .Where(x => x.Any());
        }
    }
}
​
​
// Decompiled with JetBrains decompiler
// Type: Prodrive.Maybe`1
// Assembly: Prodrive.Core, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
// MVID: 2A15C284-4230-4980-9AAD-583D09C6D7A9
// Assembly location: C:\git\manufacturing-data-collection-facade\ManufacturingDataCollectionFacade\packages\Prodrive.Core.1.3.0\lib\netstandard2.0\Prodrive.Core.dll
​
​
namespace Prodrive
{
  /// <summary>
  /// Represents a value of the underlying type or absence thereof. Allows to avoid <c>null</c>-based representation
  /// of values being undefined, absent, unknown, etc. Supports 'pattern' matching and combination of multiple
  /// <c>Maybe</c> values in one expression.
  /// </summary>
  /// <remarks>
  /// <para>
  /// Conceptually, values of type <c>Maybe</c> can have two shapes: <c>Some(v)</c> and <c>None</c>, where <c>v</c> is
  /// a value of the underlying, "wrapped" type. While this implementation does not contain these
  /// constructors explicitly, the documentation refers to <c>Maybe</c> values in terms of <c>Some</c> and
  /// <c>None</c>.
  /// </para>
  /// <para>
  /// Values of this class are immutable.
  /// </para>
  /// </remarks>
  /// <typeparam name="T">The underlying 'actual' type.</typeparam>
  public struct Maybe<T> : IEquatable<Maybe<T>>
  {
    /// <summary>
    /// The value wrapped by this <c>Maybe</c> value, if it is a <c>Some</c>.
    /// </summary>
    private readonly T value;
    /// <summary>
    /// Implements differentiation between the logical values of this type: Some and None.
    /// </summary>
    private readonly bool isSome;
​
    /// <summary>
    /// Initializes a new instance of the <see cref="T:Prodrive.Maybe`1" /> struct.
    /// If the given underlying value is <c>null</c>, initializes a
    /// <c>None</c>, otherwise a <c>Some</c>.
    /// </summary>
    /// <param name="value">
    /// The underlying value, may be <c>null</c>.
    /// </param>
    public Maybe(T value)
      : this()
    {
      this.value = value;
      this.isSome = (object) value != null;
    }
​
    /// <summary>
    /// Gets a <c>None</c> value. Essentially serves as a constructor.
    /// </summary>
    public static Maybe<T> None
    {
      get
      {
        return new Maybe<T>();
      }
    }
​
    /// <summary>
    /// Gets a value indicating whether the value represented by this <c>Maybe</c> value is present.
    /// </summary>
    public bool IsSome
    {
      get
      {
        return this.isSome;
      }
    }
​
    /// <summary>
    /// Gets a value indicating whether the value represented by this <c>Maybe</c> value is not present.
    /// </summary>
    public bool IsNone
    {
      get
      {
        return !this.isSome;
      }
    }
​
    /// <summary>
    /// Gets the value represented by this <c>Maybe</c> value, if and only if it is present. This property should
    /// not be evaluated without a guarding check using <see cref="P:Prodrive.Maybe`1.IsSome" /> or <see cref="P:Prodrive.Maybe`1.IsNone" />.
    /// </summary>
    public T Value
    {
      get
      {
        if (this.isSome)
          return this.value;
        throw new InvalidOperationException("Attempted to retrieve the value of None.");
      }
    }
​
    /// <summary>
    /// Converts a value to its <c>Maybe</c> representation. <c>null</c>-values are converted to <c>None</c>,
    /// non-<c>null</c> values to <c>Some</c>. This conversion operator allows to seamlessly use 'plain' values in
    /// expressions involving <c>Maybe</c>.
    /// </summary>
    /// <param name="value">
    /// A value to convert to <c>Maybe</c>.
    /// </param>
    /// <returns>
    /// <c>None</c> if <paramref name="value" /> is <c>null</c>, otherwise <c>Some(value)</c>.
    /// </returns>
    public static implicit operator Maybe<T>(T value)
    {
      return Maybe<T>.EliminateNull(value);
    }
​
    /// <summary>Determines whether two Maybe values are equal.</summary>
    /// <param name="i1">The first Maybe value.</param>
    /// <param name="i2">The second Maybe value.</param>
    /// <returns>
    /// <c>true</c> if the specified <c>i1.Equals(i2)</c> holds, otherwise <c>false</c>.
    /// </returns>
    public static bool operator ==(Maybe<T> i1, Maybe<T> i2)
    {
      return i1.Equals(i2);
    }
​
    /// <summary>Determines whether two Maybe value are not equal.</summary>
    /// <param name="i1">The first Maybe value.</param>
    /// <param name="i2">The second Maybe value.</param>
    /// <returns>
    /// <c>true</c> if the specified <c>i1.Equals(i2)</c> does not hold, otherwise <c>false</c>.
    /// </returns>
    public static bool operator !=(Maybe<T> i1, Maybe<T> i2)
    {
      return !i1.Equals(i2);
    }
​
    /// <summary>
    /// Matches against this <c>Maybe</c> value and performs different actions for <c>Some</c> and <c>None</c>.
    /// </summary>
    /// <param name="some">
    /// The action to be performed when this value is <c>Some(v)</c>. The wrapped value <c>v</c> is passed to the
    /// action.
    /// </param>
    /// <param name="none">
    /// The action to be performed when this value is <c>None</c>.
    /// </param>
    public void Match(Action<T> some, Action none)
    {
      if (this.isSome)
        some(this.Value);
      else
        none();
    }
​
    public U Match<U>(Func<T, U> some, Func<U> none)
    {
      return !this.isSome ? none() : some(this.Value);
    }
​
    public U Match<U>(Func<T, U> some, U none)
    {
      return !this.isSome ? none : some(this.Value);
    }
​
    public Maybe<U> Bind<U>(Func<T, Maybe<U>> func)
    {
      return !this.isSome ? Maybe<U>.None : func(this.Value);
    }
​
    /// <summary>
    /// Applies the given accumulator function over this value.
    /// </summary>
    /// <remarks>
    /// This function is sometimes called <c>Aggregate</c>, for example as an extension method on
    /// <c>IEnumerable{T}</c>.
    /// </remarks>
    /// <typeparam name="U">The result type of accumulation.</typeparam>
    /// <param name="func">
    /// An accumulator function to be invoked on the wrapped value.
    /// </param>
    /// <param name="seed">
    /// The initial value to be passed to <paramref name="func" />.
    /// </param>
    /// <returns>
    /// <paramref name="func" /> applied to <c>(v,seed)</c> if this value is <c>Some(v)</c> or
    /// <paramref name="seed" /> when this value is <c>None</c>.
    /// </returns>
    public U Fold<U>(Func<T, U, U> func, U seed)
    {
      return !this.isSome ? seed : func(this.Value, seed);
    }
​
    /// <summary>
    /// Determines equivalence with another <c>Maybe</c> value. The properties of equivalence relation on
    /// <c>Maybe</c> are as follows:
    /// <ul>
    /// <li><c>None</c> is equal to <c>None</c></li>
    /// <li><c>Some(a)</c> is not equal to <c>None</c>, for any <c>a</c></li>
    /// <li><c>Some(a)</c> is equal to <c>Some(b)</c> if and only if <c>object.Equals(a,b)</c> is true</li>
    /// </ul>
    /// </summary>
    /// <param name="other">
    /// A <c>Maybe</c> value to compare with this value.
    /// </param>
    /// <returns>
    /// <c>true</c> if this <c>Maybe</c> value equals <paramref name="other" />, otherwise <c>false</c>.
    /// </returns>
    public bool Equals(Maybe<T> other)
    {
      if (this.isSome ^ other.isSome)
        return false;
      return this.IsNone && other.IsNone || object.Equals((object) this.Value, (object) other.Value);
    }
​
    /// <summary>Determines equivalence with another object.</summary>
    /// <param name="obj">The object to compare with the current object.</param>
    /// <returns>
    /// <c>true</c> if and only if this value is equal to <paramref name="obj" />.
    /// </returns>
    public override bool Equals(object obj)
    {
        if(!(obj is Maybe<T>))
            return false;
      var other = (Maybe<T>)obj;
      return this.Equals(other);
    }
​
    /// <summary>
    /// Returns the hash code of this <c>Maybe</c> value.
    /// </summary>
    /// <returns>
    /// Hash code of <c>v</c> if this value is <c>Some(v)</c>, otherwise <c>0</c>.
    /// </returns>
    public override int GetHashCode()
    {
      return !this.isSome ? 0 : this.value.GetHashCode();
    }
​
    /// <summary>
    /// Returns the fully qualified type name of this instance.
    /// </summary>
    /// <returns>
    /// A <see cref="T:System.String" /> containing a fully qualified type name.
    /// </returns>
    /// <filterpriority>2</filterpriority>
    public override string ToString()
    {
      return !this.isSome ? string.Format("None<{0}>", (object) typeof (T).Name) : string.Format("Some<{0}> {1}", (object) typeof (T).Name, (object) this.value);
    }
​
    public Maybe<T> Where(Func<T, bool> predicate)
    {
      return (this.isSome ? (predicate(this.value) ? 1 : 0) : 0) != 0 ? new Maybe<T>(this.value) : Maybe<T>.None;
    }
​
    public Maybe<U> Select<U>(Func<T, U> selector)
    {
      return !this.isSome ? Maybe<U>.None : new Maybe<U>(selector(this.value));
    }
​
    public Maybe<V> SelectMany<U, V>(Func<T, Maybe<U>> selector, Func<T, U, V> resultSelector)
    {
      if (!this.isSome)
        return Maybe<V>.None;
      T obj = this.value;
      Maybe<U> maybe = selector(obj);
      return !maybe.isSome ? Maybe<V>.None : new Maybe<V>(resultSelector(obj, maybe.value));
    }
​
    /// <summary>
    /// Wraps this <see cref="T:Prodrive.Maybe`1" /> in an <see cref="T:System.Collections.Generic.IEnumerable`1" />.
    /// </summary>
    /// <returns>
    /// Returns this <see cref="T:Prodrive.Maybe`1" /> wrapped in an <see cref="T:System.Collections.Generic.IEnumerable`1" />.
    /// </returns>
    public IEnumerable<T> AsEnumerable()
    {
      if (this.isSome)
        yield return this.value;
    }
​
    /// <summary>
    /// Wraps the given value in <c>None</c> if it is <c>null</c>, otherwise in <c>Some</c>.
    /// </summary>
    /// <param name="value">
    /// A value, may be <c>null</c>.
    /// </param>
    /// <returns>
    /// The <c>Maybe</c> representation of <paramref name="value" />.
    /// </returns>
    internal static Maybe<T> EliminateNull(T value)
    {
      return (object) value == null ? Maybe<T>.None : new Maybe<T>(value);
    }
  }
}
​

View IL Code