// Why do we have null everywhere in our code? Why can so many things be assigned a value that causes countless runtime exceptions?

​

// The Answer: The Option Type

​

// It eliminates all null runtime exceptions entirely, and turns them instead to compiler exceptions that you fix.

​

using System;

using LanguageExt;

using static LanguageExt.Prelude;

​

public class NullFreeProgram

{

    public static void Main()

    {

        LinqPatternMatchingExample();

        OptionExample();

        Console.WriteLine("Null free rocks!");

    }

    public static Unit LinqPatternMatchingExample()

    {

        Option<int> two = Some(2);

        Option<int> four = Some(4);

        Option<int> bad = None; // assigning null here creates a compiler error, rather than a runtime error

​

        // This expression succeeds because all items to the right of 'in' are Some of int

        // and therefore it lands in the Some lambda.

        var r1 = match(from x in two

                       from y in four

                       select x + y,

                       Some: v => v * 2,

                       None: () => 0 ); 

        AssertEqual(r1, 12);

​

        // This expression bails out once it gets to the None, and therefore doesn't calculate x+y+bad

        // and lands in the None lambda

        var r2 = match(from x in two

                       from y in four

                       from z in bad

                       select x + y + z,

                       Some: v => v * 2,

                       None: () => 0 );

        AssertEqual(r2, 0);

        return unit;

    }

    public static Unit OptionExample()

    {

        var optional = Some(120); // This is how you create an Option<int>:

​

        // To access the value you must check that it's valid first:

​

        int x1 = optional.Match( 

            Some: v  => v * 2,

            None: () => 0 

        );

        AssertEqual(x1, 240);

​

        // An alternative (functional) way of matching is this:

​

        int x2 = match( optional, 

                      Some: v  => v * 3,

                      None: () => 0 );

        AssertEqual(x2, 360);

​

        // Yet another alternative ("fluent") matching method is this:

​

        int x3 = optional

            .Some( v  => v / 2 )

            .None( () => 0 );

        AssertEqual(x3, 60);

​

        // Teams can choose their preferred method and stick with it. It's probably best not to mix styles.

        return unit;        

    }

    public static Unit AssertEqual(dynamic first, dynamic second) 

    {

        if (first != second) 

        {

            throw new Exception($"Assertion failed: expected {first} to be {second}");

        }

        return unit;

    }

}