Add my own work for exercises 1-10

.gitignore

@@ -416,3 +416,4 @@ FodyWeavers.xsd
 *.msix
 *.msm
 *.msp
+whyfp90.pdf

Mark-CSharp/.gitignore

@@ -0,0 +1,8 @@
+#Ignore any test result output from unit testing
+/[T][t]est[R][r]esults/
+
+# Ignore .idea folder
+/.idea/
+
+# Ignore any personal settings
+*.[D][d]ot[S][s]ettings.*

Mark-CSharp/WhyFunctional.Tests/ListOfExtensionsTests.cs

@@ -0,0 +1,201 @@
+using FluentAssertions;
+
+namespace WhyFunctional.Tests;
+
+[TestClass]
+public class ListOfExtensionsTests
+{
+	[TestMethod]
+	[DataRow(new int[] { 1 })]
+	[DataRow(new int[] { 10 })]
+	[DataRow(new int[] { 1, 2, 3 })]
+	public void VerifySumExtension(int[] values)
+	{
+		int expected = 0;
+		ListOf<int> sut = ListOf<int>.Nil();
+		foreach (int value in values.Reverse())
+		{
+			sut = ListOf<int>.Cons(value, sut);
+			expected += value;
+		}
+
+		var result = sut.Sum<int, int>();
+		result.Should().Be(expected);
+	}
+
+	[TestMethod]
+	[DataRow(new int[] { 1 })]
+	[DataRow(new int[] { 10 })]
+	[DataRow(new int[] { 1, 2, 3 })]
+	public void VerifyProductExtension(int[] values)
+	{
+		int expected = 1;
+		ListOf<int> sut = ListOf<int>.Nil();
+		foreach (int value in values.Reverse())
+		{
+			sut = ListOf<int>.Cons(value, sut);
+			expected *= value;
+		}
+
+		var result = sut.Product<int, int>();
+		result.Should().Be(expected);
+	}
+
+	[TestMethod]
+	[DataRow(new int[] { })]
+	[DataRow(new int[] { 1 })]
+	[DataRow(new int[] { 1, 2, 3, 5, 7 })]
+	public void VerifyBuildListExtension(int[] values)
+	{
+		ListOf<int> sut = values.BuildList();
+
+		sut.Should().NotBeNull();
+		sut.ToArray.Length.Should().Be(values.Length);
+		sut.ToArray.Should().ContainInOrder(values);
+	}
+
+	[TestMethod]
+	[DataRow(new bool[] { }, false)]
+	[DataRow(new bool[] { false }, false)]
+	[DataRow(new bool[] { false, false, true }, true)]
+	[DataRow(new bool[] { false, true, false }, true)]
+	public void VerifyAnyTrueExtension(bool[] values, bool expected)
+	{
+		ListOf<bool> sut = values.BuildList();
+
+		sut.Should().NotBeNull();
+		sut.ToArray.Length.Should().Be(values.Length);
+		sut.ToArray.Should().ContainInOrder(values);
+		ListOfExtensions.AnyTrue(sut).Should().Be(expected);
+	}
+
+	[TestMethod]
+	[DataRow(new bool[] { }, true)]
+	[DataRow(new bool[] { false }, false)]
+	[DataRow(new bool[] { false, false, true }, false)]
+	[DataRow(new bool[] { false, true, false }, false)]
+	[DataRow(new bool[] { true }, true)]
+	[DataRow(new bool[] { true, true }, true)]
+	[DataRow(new bool[] { true, true, false }, false)]
+	public void VerifyAllTrueExtension(bool[] values, bool expected)
+	{
+		ListOf<bool> sut = values.BuildList();
+
+		sut.Should().NotBeNull();
+		sut.ToArray.Length.Should().Be(values.Length);
+		sut.ToArray.Should().ContainInOrder(values);
+		ListOfExtensions.AllTrue(sut).Should().Be(expected);
+	}
+
+	[TestMethod]
+	[DataRow(new int[] { })]
+	[DataRow(new int[] { 1 })]
+	[DataRow(new int[] { 10, 20, 30 })]
+	public void VerifyCopyExtension(int[] values)
+	{
+		ListOf<int> sut = values.BuildList();
+
+		ListOf<int> copy = sut.Copy();
+
+		sut.Should().NotBeNull();
+		copy.Should().NotBeNull();
+		copy.Should().NotBeSameAs(sut);
+		copy.ToArray.Length.Should().Be(sut.ToArray.Length);
+		copy.ToArray.Should().ContainInOrder(sut.ToArray);
+	}
+
+	[TestMethod]
+	[DataRow(new int[] { }, new int[] { })]
+	[DataRow(new int[] { 1 }, new int[] { 2 })]
+	[DataRow(new int[] { 1 }, new int[] { })]
+	[DataRow(new int[] { }, new int[] { 2 })]
+	[DataRow(new int[] { 1, 11 }, new int[] { 2, 22 })]
+	[DataRow(new int[] { 1, 2 }, new int[] { 3, 4 })]
+	public void VerifyAppendExtension(int[] lhs, int[] rhs)
+	{
+		ListOf<int> first = lhs.BuildList();
+		ListOf<int> second = rhs.BuildList();
+
+		first.Should().NotBeNull();
+		second.Should().NotBeNull();
+
+		int[] expectedAppend = lhs.Concat(rhs).ToArray();
+
+		ListOf<int> sut = first.Append(second);
+
+		sut.Should().NotBeNull();
+		sut.ToArray.Length.Should().Be(expectedAppend.Length);
+		sut.ToArray.Should().ContainInOrder(expectedAppend);
+	}
+
+	[TestMethod]
+	[DataRow(new int[] { }, 0)]
+	[DataRow(new int[] { 1 }, 1)]
+	[DataRow(new int[] { 1, 1 }, 2)]
+	[DataRow(new int[] { 1, 1, 1, 1 }, 4)]
+	public void VerifyLengthExtension(int[] values, int expectedLength)
+	{
+		ListOf<int> sut = values.BuildList();
+
+		sut.Should().NotBeNull();
+		sut.Length().Should().Be(expectedLength);
+	}
+
+	[TestMethod]
+	[DataRow(new int[] { })]
+	[DataRow(new int[] { 1 })]
+	[DataRow(new int[] { 1, 2 })]
+	[DataRow(new int[] { 1, 2, 3 })]
+	[DataRow(new int[] { 4, 3, 2, 1 })]
+	public void VerifyDoubleAllExtension(int[] values)
+	{
+		ListOf<int> initial = values.BuildList();
+		int[] expected = values.Select(v => 2 * v).ToArray();
+
+		initial.Should().NotBeNull();
+
+		ListOf<int> sut = initial.DoubleAll();
+		sut.Should().NotBeNull();
+		sut.Should().NotBeSameAs(initial);
+		sut.ToArray.Length.Should().Be(expected.Length);
+		sut.ToArray.Should().ContainInOrder(expected);
+	}
+	[TestMethod]
+	[DataRow(new int[] { })]
+	[DataRow(new int[] { 1 })]
+	[DataRow(new int[] { 1, 2 })]
+	[DataRow(new int[] { 1, 2, 3 })]
+	[DataRow(new int[] { 4, 3, 2, 1 })]
+	public void VerifyDoubleAllExExtension(int[] values)
+	{
+		ListOf<int> initial = values.BuildList();
+		int[] expected = values.Select(v => 2 * v).ToArray();
+
+		initial.Should().NotBeNull();
+
+		ListOf<int> sut = initial.DoubleAllEx();
+		sut.Should().NotBeNull();
+		sut.Should().NotBeSameAs(initial);
+		sut.ToArray.Length.Should().Be(expected.Length);
+		sut.ToArray.Should().ContainInOrder(expected);
+	}
+	[TestMethod]
+	[DataRow(new int[] { })]
+	[DataRow(new int[] { 1 })]
+	[DataRow(new int[] { 1, 2 })]
+	[DataRow(new int[] { 1, 2, 3 })]
+	[DataRow(new int[] { 4, 3, 2, 1 })]
+	public void VerifyTripleAllExtension(int[] values)
+	{
+		ListOf<int> initial = values.BuildList();
+		int[] expected = values.Select(v => 3 * v).ToArray();
+
+		initial.Should().NotBeNull();
+
+		ListOf<int> sut = initial.TripleAll();
+		sut.Should().NotBeNull();
+		sut.Should().NotBeSameAs(initial);
+		sut.ToArray.Length.Should().Be(expected.Length);
+		sut.ToArray.Should().ContainInOrder(expected);
+	}
+}

Mark-CSharp/WhyFunctional.Tests/ListOfTests.cs

@@ -0,0 +1,95 @@
+using FluentAssertions;
+
+namespace WhyFunctional.Tests;
+
+[TestClass]
+public sealed class ListOfTests
+{
+	[TestMethod]
+	public void VerifyNilProducesEmptyResult()
+	{
+		ListOf<int> sut = ListOf<int>.Nil();
+
+		sut.Should().NotBeNull();
+		sut.ToArray.Should().BeEmpty();
+		sut.IsNil.Should().BeTrue();
+	}
+
+	[TestMethod]
+	public void VerifySingleElement()
+	{
+		ListOf<int> sut = ListOf<int>.Cons(1, ListOf<int>.Nil());
+
+		sut.Should().NotBeNull();
+		int[] values = sut.ToArray;
+		values.Should().NotBeEmpty();
+		values.Should().HaveCount(1);
+		values.Should().Contain(1);
+		sut.IsNil.Should().BeFalse();
+	}
+
+	[TestMethod]
+	public void VerifyThreeElements()
+	{
+		ListOf<int> sut = ListOf<int>.Cons(1, ListOf<int>.Cons(2, ListOf<int>.Cons(3, ListOf<int>.Nil())));
+
+		sut.Should().NotBeNull();
+		int[] values = sut.ToArray;
+		values.Should().NotBeEmpty();
+		values.Should().HaveCount(3);
+		values.Should().Contain([1, 2, 3]);
+		sut.IsNil.Should().BeFalse();
+	}
+
+	[TestMethod]
+	[DataRow(new int[] { 1 }, 1)]
+	[DataRow(new int[] { 13, 27, 3 }, 13)]
+	public void VerifyHeadProperty(int[] values, int expected)
+	{
+		ListOf<int> sut = ListOf<int>.Nil();
+		foreach (int value in values.Reverse())
+		{
+			sut = ListOf<int>.Cons(value, sut);
+		}
+
+		sut.Should().NotBeNull();
+		int[] sutValues = sut.ToArray;
+		sutValues.Should().HaveCount(values.Length);
+		sutValues.Should().Contain(expected);
+		sut.IsNil.Should().BeFalse();
+		sut.Head.Should().Be(expected);
+	}
+
+	public static IEnumerable<object[]> VerifyTailTestData()
+	{
+		var tv_1 = ListOf<int>.Cons(1, ListOf<int>.Nil());
+		var tv_3 = ListOf<int>.Cons(3, ListOf<int>.Nil());
+		var tv_27 = ListOf<int>.Cons(27, tv_3);
+		var tv_13 = ListOf<int>.Cons(13, tv_27);
+		return
+		[
+			[tv_1.ToArray, tv_1.Head, Array.Empty<int>()],
+			[tv_13.ToArray, tv_13.Head, tv_27.ToArray]
+		];
+	}
+
+	[TestMethod]
+	[DynamicData(nameof(VerifyTailTestData), DynamicDataSourceType.Method)]
+	public void VerifyTailProperty(int[] values, int expectedHead, int[] expectedTail)
+	{
+		ListOf<int> sut = ListOf<int>.Nil();
+		foreach (int value in values.Reverse())
+		{
+			sut = ListOf<int>.Cons(value, sut);
+		}
+
+		sut.Should().NotBeNull();
+		int[] sutValues = sut.ToArray;
+		sutValues.Should().HaveCount(values.Length);
+		sutValues.Should().Contain(expectedHead);
+		sut.IsNil.Should().BeFalse();
+		sut.Head.Should().Be(expectedHead);
+		sut.Tail.ToArray.Should().HaveCount(expectedTail.Length);
+		sut.Tail.ToArray.Should().ContainInOrder(expectedTail);
+	}
+}

Mark-CSharp/WhyFunctional.Tests/MSTestSettings.cs

@@ -0,0 +1 @@
+[assembly: Parallelize(Scope = ExecutionScope.MethodLevel)]

Mark-CSharp/WhyFunctional.Tests/WhyFunctional.Tests.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="FluentAssertions" Version="7.2.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="MSTest" Version="3.6.4" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\WhyFunctional\WhyFunctional.csproj" />
+  </ItemGroup>
+
+</Project>

Mark-CSharp/WhyFunctional.sln

@@ -0,0 +1,48 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31903.59
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WhyFunctional", "WhyFunctional\WhyFunctional.csproj", "{8F6902EC-8687-4F79-AA2F-F3A1CF7191F4}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WhyFunctional.Tests", "WhyFunctional.Tests\WhyFunctional.Tests.csproj", "{BCDE153E-CE0B-461C-AC74-35B230F3DE56}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|Any CPU = Release|Any CPU
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{8F6902EC-8687-4F79-AA2F-F3A1CF7191F4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8F6902EC-8687-4F79-AA2F-F3A1CF7191F4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8F6902EC-8687-4F79-AA2F-F3A1CF7191F4}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{8F6902EC-8687-4F79-AA2F-F3A1CF7191F4}.Debug|x64.Build.0 = Debug|Any CPU
+		{8F6902EC-8687-4F79-AA2F-F3A1CF7191F4}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{8F6902EC-8687-4F79-AA2F-F3A1CF7191F4}.Debug|x86.Build.0 = Debug|Any CPU
+		{8F6902EC-8687-4F79-AA2F-F3A1CF7191F4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{8F6902EC-8687-4F79-AA2F-F3A1CF7191F4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8F6902EC-8687-4F79-AA2F-F3A1CF7191F4}.Release|x64.ActiveCfg = Release|Any CPU
+		{8F6902EC-8687-4F79-AA2F-F3A1CF7191F4}.Release|x64.Build.0 = Release|Any CPU
+		{8F6902EC-8687-4F79-AA2F-F3A1CF7191F4}.Release|x86.ActiveCfg = Release|Any CPU
+		{8F6902EC-8687-4F79-AA2F-F3A1CF7191F4}.Release|x86.Build.0 = Release|Any CPU
+		{BCDE153E-CE0B-461C-AC74-35B230F3DE56}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{BCDE153E-CE0B-461C-AC74-35B230F3DE56}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{BCDE153E-CE0B-461C-AC74-35B230F3DE56}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{BCDE153E-CE0B-461C-AC74-35B230F3DE56}.Debug|x64.Build.0 = Debug|Any CPU
+		{BCDE153E-CE0B-461C-AC74-35B230F3DE56}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{BCDE153E-CE0B-461C-AC74-35B230F3DE56}.Debug|x86.Build.0 = Debug|Any CPU
+		{BCDE153E-CE0B-461C-AC74-35B230F3DE56}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{BCDE153E-CE0B-461C-AC74-35B230F3DE56}.Release|Any CPU.Build.0 = Release|Any CPU
+		{BCDE153E-CE0B-461C-AC74-35B230F3DE56}.Release|x64.ActiveCfg = Release|Any CPU
+		{BCDE153E-CE0B-461C-AC74-35B230F3DE56}.Release|x64.Build.0 = Release|Any CPU
+		{BCDE153E-CE0B-461C-AC74-35B230F3DE56}.Release|x86.ActiveCfg = Release|Any CPU
+		{BCDE153E-CE0B-461C-AC74-35B230F3DE56}.Release|x86.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal