LanguageExt 0.0.14-beta

• .NETFramework 4.5

  • System.Collections.Immutable (>= 1.1.32-beta)

### Operators

`None` and `Left` coalescing using the logical-or operator.

This means chaining of optional values with defaults:

  Option<int> optional1 = None;
  Option<int> optional2 = None;

  var res = optional1 || optional2 || "Default";  
  // Some("Default")

This also means you can use them in LINQ expressions where `from` is logical-AND and `||` is logical-OR:

   Option<int> optional1 = None;
   Option<int> optional2 = Some(10);
   Option<int> optional3 = Some(20);

   var res = from x in optional1 || optional2
             from y in optional3
             select x + y;

   // Some(30)

`true` and `false` operators implemented for option and either types.

   var optional = Some(123);
   if( optional )
   {
      // true
   }

`==` and `!=` operators implemented for option and either types:

   var optional = Some(123);
   if( optional == 123 )
   {
      // true
   }

   Option<int> optional = None;
   if( optional == None )
   {
      // true
   }

### With

`with(Tuple,..)` and `With(Tuple,..)` are now `map(Tuple,..)` and `Map(Tuple,..)`.  They were poorly named, these are more consistent with their action.  The `with` functions that take up to 5 parameters are also renamed `map`.

The old `with` functions have been marked `[Obsolete]`

Thanks to @tomaszpolanski for the feedback
https://github.com/louthy/language-ext/issues/15

### Optional

Added `Optional`, it will take `T` or `null` and return a `Some(T)` or `None` respectively.  This is for where you want to be explicit about the conversion from `T` to `Some(T)|None`, and for when the type system complains at you (in the branches of a ternary operator for example):

  string x = GetValueFromNonTrustedAPI();
  return Optional(x);

Thanks to @tejacques for the feedback:
https://github.com/louthy/language-ext/issues/12


... and Various bug fixes