// Lazily tries 3 different functions and tries to return the first non-empty result, in this case // it will return an IEnumerator containing "hello" and never call SomeReallyExpensiveFunction return [ () => Optional<string>.Empty, () => Optional.Of("hello"), () => SomeReallyExpensiveFunction() ].TakePresent(1); // Evaluates optional values in a collection and returns the first 2 non-empty results, in this case // it will return an Optional containing "hello" and "world" return [ Optional.Of("hello"), Optional<string>.Empty, Optional.Of("world") ].TakePresent(2); # New in 3.6 * Added Optional.Coalesce() and Optional.First() methods for handling collections of optional values and collections-of-functions that return optional values ```c# // Lazily tries 3 different functions and returns the first non-empty result, in this case // it will return an Optional containing "hello" and will never call SomeReallyExpensiveFunction() return Optional.Coalesce([ () => Optional.Of("hello"), () => Optional<string>.Empty, () => SomeReallyExpensiveFunction() ]); // Evaluates optional values in a collection and returns the first non-empty result, in this case // it will return an Optional containing "hello" and will never call SomeReallyExpensiveFunction() return Optional.First([ Optional<string>.Empty, Optional.Of("hello"), Optional.Of("word") ]);

// Lazily tries 3 different functions and returns the first non-empty result, otherwise // falling back to false at the end if none of them returned a value return await TrySomethingAsync() // If TrySomethingAsync() returns empty, execute the function chain below // This is lazily executed, so it will never execute if TrySomethingAsync() returns something. .OrElseAsync(() => TrySomethingElseAsync().MapAsync(somethingElse => { return "fallback-value-1"; }) // If _that_ didn't work, lazily try this instead! .OrElseAsync(async () => { if (await SomethingElse()) { return Optional.Of("fallback-value-2"); } return Optional.Empty; }) // Nothing worked, but we might want to provide a default value .OrElseAsync(() => { Log.Warn("nothing worked!"); return "oh no!"; });

// Chain async optional tasks together, the tasks only execute if the previous task returned a value Task<Optional<long>> input = Task.FromResult(Optional.Of(1234567890L)); Optional<string> output = await input.FlatMapAsync(async x => x.ToString()); // Rethrow exceptions in a clean manner via OrElseThrow() try { SomethingThatMightThrow(); } catch (Exception ex) { SomeFallbackThingThatReturnsOptional().OrElseThrow(ex); // Original call stack of ex is preserved } // Perform some async computation that might return a result, // map the result or fall back to another value! string result = await Func() .MapAsync(async x => x + " even more string") .OrElseAsync(() => "Fallback from async optional method chain"); async Task<Optional<string>> Func() { return Optional.Empty; }

string result = await SomeAsyncFunc().OrElseAsync(() => "hello!"); Optional<T> result = await SomeAsyncFunc().OrElseAsync(SomeOtherFunThatReturnsOptional); Optional<string> result = await Task.FromResult("Hello").MapAsync(x => x + " World!"); Optional<string> result = await SomeAsyncFunc().MapAsync(async x => "Hello from an async Task {x}!");

class MyCSharpClass { public static Optional<string> DoSomething() => Optional.Of(42) // Return an Optional.net option }

void Main() { SomeOtherFunc().IfPresent(value => Console.WriteLine(value)); } Optional<string> SomeOtherFunc() { return Optional.Of(someField).IfNotPresent(() => "fallback value"); }

void Main() { var value = Optional.Of(NullableLibraryFunction()).OrElse("treachery!"); }

string SomeFunc() { return "test"; } Optional<string> result = SomeFunc(); result.IfPresent(x => Console.WriteLine(x));

string SomeFunc() { return null; } Optional<string> foo = SomeFunc(); Console.WriteLine($"Result HasValue = {foo.HasValue}");

void Main() { var value = Optional.get(Func1, Func2, Func3); } Optional<int> Func1() { return Optional.Empty; } Optional<int> Func2() { return Optional.Empty; } Optional<int> Func3() { return Optional.Of(42); }

async Task Main() { // Mix sync and async functions using Optionals await SomeFunc().IfPresentAsync(value => { await DoAsyncWork(value); Console.WriteLine("Async!"); }); // Compose optional async tasks together! Optional<char[]> _ = await SomeFunc().MapAsync(x => { return x.ToArray(); }); } Optional<string> SomeFunc() { return Optional.Of("test"); } async Task DoAsyncWork(string value) { await File.WriteAllTextAsync("./file.text", value); }

void Main() { Func1().Map(x => x + "mapping ") .Map(x => x + "values ") .Map(x => new StringBuilder(x)) .Map(x => x.Append("safely!")) .Map(x => SomeFunctionThatMightReturnNull(x)) .IfPresent(x => Console.WriteLine(x.ToString())); }

void Main() { var result = MaybeSomething().OrElse(() => "Something else")) } Optional<string> MaybeSomething() { return Optional.Empty; }

void Main() { IEnumerable<Optional<string>> results = Optional.Pack(SomeLibraryFunctionThatReturnsAString(), AnotherFunctionThatMightReturnNull(), AnotherFunction()); // Pick all of the non-empty values from the list, discarding the empty ones Optional.UnpackPartial(results).IfPresent(listOfOnlyPresentValues => { Console.WriteLine("At least one value was present"); foreach(var val in listOfOnlyPresentValues) { Console.WriteLine(val); } }) .IfNotPresent(() => Console.WriteLine("All values were empty!")) // Create an IEnumerable<T> if ALL values in "results" are present, otherwise return empty Optional.UnpackAll(results).IfPresent(listOfAllValues => { foreach(var val in listOfAllValues) { Console.WriteLine(val); } }); }