Merge pull request #28

V2.1.0

DocumentationHelp.ipynb

@@ -0,0 +1,20 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Getting Started\n",
+    "\n",
+    "MkDocs uses a python package installed locally in the virtual environment. In order to run the documentation site to inspect it locally before publishing, run the command `mkdocs serve`."
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

Functional.Test/Common/CommonExtensionTests.cs

@@ -1,6 +1,5 @@
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
-
 using static Functional.Common.CommonExtensions;
 
 namespace Functional.Test.Common;
@@ -24,7 +23,7 @@ public void MapShouldConvertIntToString() =>
     /// </summary>
     [TestMethod]
     public void ItShouldTapResults() =>
-        new TestObject() { Value = 1 }
+        new TestObject { Value = 1 }
             .Tap(objToChange => objToChange.Value = 2)
             .ShouldBeEquivalentTo(new TestObject() { Value = 2 });
 
@@ -108,14 +107,14 @@ public void ConsShouldAddItemsToAnImmutableList() =>
             "1",
             "2",
         }
-        .Pipe(strs => ImmutableList<string>.Empty.AddRange(strs))
-        .Tap(strs => Cons("1", "2").ShouldBeEquivalentTo(strs))
+        .Pipe(strings => ImmutableList<string>.Empty.AddRange(strings))
+        .Tap(strings => Cons("1", "2").ShouldBeEquivalentTo(strings))
         .Ignore();
 
     /// <summary>
     /// A test object to mock data mutation behavior.
     /// </summary>
-    internal class TestObject
+    private class TestObject
     {
         internal int Value { get; set; }
 
@@ -132,21 +131,20 @@ internal Task<int> AddOneAsync()
     /// A test record to verify behavior mapping with records.
     /// </summary>
     /// <param name="Value">The value to store.</param>
-    internal record TestRecord(int Value);
+    private record TestRecord(int Value);
 
     [TestMethod]
     public async Task ItShouldAllowActionsPassedToTapAsync() =>
-        await new TestObject() { Value = 1 }
+        await new TestObject { Value = 1 }
             .AsAsync()
             .TapAsync(obj => obj.AddOne())
             .TapAsync(obj => obj.Value.ShouldBe(2));
 
     [TestMethod]
     public async Task ItShouldAllowTaskMappersToBePassedToTapAsync() =>
-        await new TestObject() { Value = 1 }
+        await new TestObject { Value = 1 }
             .AsAsync()
             .PipeAsync(obj => obj.AddOneAsync())
-            .TapAsync(obj => Task.FromResult(obj))
+            .TapAsync(Task.FromResult)
             .TapAsync(number => number.ShouldBe(2));
-
 }

Functional.Test/Options/OptionTests.cs

@@ -182,11 +182,11 @@ public async Task ItShouldHandleAsyncNoneOptions() =>
     public async Task ItShouldHandleAsyncSomeOptions() =>
         await AlwaysReturnsNullableString("input")
             .Optional()
-            .TapAsync(result => result.ShouldBeEquivalentTo(Option.Some("input")));
+            .TapAsync(result => result.ShouldBeEquivalentTo("input".Some()));
 
     [TestMethod]
     public async Task ItShouldMapOptionOfTaskOfString() =>
-        await Option.Some("input")
+        await "input".Some()
             .Map(input => input.AsAsync())
             .MapAsync(value => value + "!")
             .ReduceAsync("Oops.")
@@ -452,4 +452,124 @@ await Option.None<string>()
 
         msg.ShouldBe("None");
     }
+
+    [TestMethod]
+    public async Task ItShouldNotReturnTaskOfTaskWhenSome()
+    {
+        var taskOfTask =
+            "something"
+                .Optional()
+                .AsAsync()
+                .MatchAsync(
+                    some => some.AsAsync(),
+                    () => "none".AsAsync());
+
+        (await taskOfTask).ShouldBeOfType<string>();
+    }
+
+    [TestMethod]
+    public async Task ItShouldNotReturnTaskOfTaskWhenNone()
+    {
+        var taskOfTask =
+            Option.None<string>()
+                .AsAsync()
+                .MatchAsync(
+                    some => some.AsAsync(),
+                    () => "none".AsAsync());
+
+        (await taskOfTask).ShouldBeOfType<string>();
+    }
+
+    [TestMethod]
+    public async Task ItShouldNotReturnTaskOfTaskWhenSome1()
+    {
+        var taskOfTask =
+            "something"
+                .Optional()
+                .AsAsync()
+                .MatchAsync(
+                    some => some.AsAsync(),
+                    () => "none");
+
+        (await taskOfTask).ShouldBeOfType<string>();
+    }
+
+    [TestMethod]
+    public async Task ItShouldNotReturnTaskOfTaskWhenNone1()
+    {
+        var taskOfTask =
+            Option.None<string>()
+                .AsAsync()
+                .MatchAsync(
+                    some => some.AsAsync(),
+                    () => "none");
+
+        (await taskOfTask).ShouldBeOfType<string>();
+    }
+
+    [TestMethod]
+    public async Task ItShouldNotReturnTaskOfTaskWhenSome2()
+    {
+        var taskOfTask =
+            "something"
+                .Optional()
+                .AsAsync()
+                .MatchAsync(
+                    some => some,
+                    () => "none".AsAsync());
+
+        (await taskOfTask).ShouldBeOfType<string>();
+    }
+
+    [TestMethod]
+    public async Task ItShouldNotReturnTaskOfTaskWhenNone2()
+    {
+        var taskOfTask =
+            Option.None<string>()
+                .AsAsync()
+                .MatchAsync(
+                    some => some,
+                    () => "none".AsAsync());
+
+        (await taskOfTask).ShouldBeOfType<string>();
+    }
+
+    [TestMethod]
+    public async Task ItShouldNotReturnTaskOfTaskWhenSome3()
+    {
+        var taskOfTask =
+            "something"
+                .Optional()
+                .AsAsync()
+                .MatchAsync(
+                    some => some,
+                    () => "none");
+
+        (await taskOfTask).ShouldBeOfType<string>();
+    }
+
+    [TestMethod]
+    public async Task ItShouldNotReturnTaskOfTaskWhenNone3()
+    {
+        var taskOfTask =
+            Option.None<string>()
+                .AsAsync()
+                .MatchAsync(
+                    some => some,
+                    () => "none");
+
+        (await taskOfTask).ShouldBeOfType<string>();
+    }
+
+    [TestMethod]
+    public async Task ItShouldHandleValueTasks()
+    {
+        var option = 
+            ValueTask
+                .FromResult(1)
+                .Optional();
+
+        (await option)
+                .ShouldBeOfType<Option<int>>();
+    }
 }