diff --git a/.gitignore b/.gitignore
index ce89292..29bbcb7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -416,3 +416,4 @@ FodyWeavers.xsd
 *.msix
 *.msm
 *.msp
+whyfp90.pdf
diff --git a/Mark-CSharp/.gitignore b/Mark-CSharp/.gitignore
new file mode 100644
index 0000000..1c97ff6
--- /dev/null
+++ b/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.*
diff --git a/Mark-CSharp/WhyFunctional.Tests/ListOfExtensionsTests.cs b/Mark-CSharp/WhyFunctional.Tests/ListOfExtensionsTests.cs
new file mode 100644
index 0000000..17f1ad4
--- /dev/null
+++ b/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);
+	}
+}
\ No newline at end of file
diff --git a/Mark-CSharp/WhyFunctional.Tests/ListOfTests.cs b/Mark-CSharp/WhyFunctional.Tests/ListOfTests.cs
new file mode 100644
index 0000000..5076487
--- /dev/null
+++ b/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);
+	}
+}
\ No newline at end of file
diff --git a/Mark-CSharp/WhyFunctional.Tests/MSTestSettings.cs b/Mark-CSharp/WhyFunctional.Tests/MSTestSettings.cs
new file mode 100644
index 0000000..aaf278c
--- /dev/null
+++ b/Mark-CSharp/WhyFunctional.Tests/MSTestSettings.cs
@@ -0,0 +1 @@
+[assembly: Parallelize(Scope = ExecutionScope.MethodLevel)]
diff --git a/Mark-CSharp/WhyFunctional.Tests/WhyFunctional.Tests.csproj b/Mark-CSharp/WhyFunctional.Tests/WhyFunctional.Tests.csproj
new file mode 100644
index 0000000..2585ecb
--- /dev/null
+++ b/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>
diff --git a/Mark-CSharp/WhyFunctional.sln b/Mark-CSharp/WhyFunctional.sln
new file mode 100644
index 0000000..fb0701b
--- /dev/null
+++ b/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
diff --git a/Mark-CSharp/WhyFunctional/ListOf.cs b/Mark-CSharp/WhyFunctional/ListOf.cs
new file mode 100644
index 0000000..c3525b4
--- /dev/null
+++ b/Mark-CSharp/WhyFunctional/ListOf.cs
@@ -0,0 +1,108 @@
+namespace WhyFunctional;
+
+public class ListOf<T>
+	where T : notnull
+{
+	#region Fields
+
+	/// <summary>
+	/// Holds the first value for the object
+	/// </summary>
+	private readonly T _value = default(T)!;
+
+	/// <summary>
+	/// Holds all other values for the object
+	/// </summary>
+	private readonly ListOf<T> _others = null!;
+
+	#endregion
+
+	#region Properties
+
+	/// <summary>
+	/// Helper property to indicate whether the value of the object is Nil
+	/// </summary>
+	public bool IsNil { get; }
+
+	/// <summary>
+	/// Helper property converts all values into an array
+	/// </summary>
+	public T[] ToArray
+	{
+		get
+		{
+			return IsNil
+				? Array.Empty<T>()
+				: new T[] { _value }.Concat(_others.ToArray).ToArray();
+		}
+	}
+
+	/// <summary>
+	/// Returns the value at the "head" of the <see cref="ListOf{T}"/>
+	/// </summary>
+	public T Head => _value;
+
+	/// <summary>
+	/// Returns the value of the other items in the <see cref="ListOf{T}"/>
+	/// </summary>
+	public ListOf<T> Tail => _others;
+
+	#endregion
+
+	#region Constructors
+
+	/// <summary>
+	/// Default ctor - creates an object equivalent to <see cref="Nil"/>
+	/// </summary>
+	private ListOf()
+	{
+		IsNil = true;
+	}
+
+	/// <summary>
+	/// Alternate ctor - must supply both values as non-null
+	/// </summary>
+	/// <param name="value">The first value</param>
+	/// <param name="others">The other values</param>
+	private ListOf(T value, ListOf<T> others)
+	{
+		ArgumentNullException.ThrowIfNull(value, nameof(value));
+		ArgumentNullException.ThrowIfNull(others, nameof(others));
+		_value = value;
+		_others = others;
+		IsNil = false;
+	}
+
+	#endregion
+
+	#region Methods
+
+	/// <summary>
+	/// Static method returns the equivalent of an object with an empty array
+	/// </summary>
+	/// <returns>The newly created empty object</returns>
+	public static ListOf<T> Nil()
+	{
+		return new ListOf<T>();
+	}
+
+	/// <summary>
+	/// Static "constructor" to initialise the object with two non-null values
+	/// </summary>
+	/// <param name="value">The first value for the object</param>
+	/// <param name="others">All other values</param>
+	/// <returns>The newly created object containing the specified values</returns>
+	public static ListOf<T> Cons(T value, ListOf<T> others)
+	{
+		return new ListOf<T>(value, others);
+	}
+
+	#endregion
+
+	public override string ToString()
+	{
+		return IsNil
+			? "Nil"
+			: $"[{Head}, {Tail}]";
+	}
+}
\ No newline at end of file
diff --git a/Mark-CSharp/WhyFunctional/ListOfExtensions.cs b/Mark-CSharp/WhyFunctional/ListOfExtensions.cs
new file mode 100644
index 0000000..d820a13
--- /dev/null
+++ b/Mark-CSharp/WhyFunctional/ListOfExtensions.cs
@@ -0,0 +1,236 @@
+using System.Numerics;
+
+namespace WhyFunctional;
+
+public static class ListOfExtensions
+{
+	/// <summary>
+	/// Returns the summation of the values contained within <paramref name="list"/>
+	/// </summary>
+	/// <param name="list">A <seealso cref="ListOf{T}"/> values to be summed</param>
+	/// <typeparam name="T"></typeparam>
+	/// <typeparam name="TResult"></typeparam>
+	/// <returns>The summation result of values held in <paramref name="list"/></returns>
+	public static TResult Sum<T, TResult>(this ListOf<T> list)
+		where T : INumber<T>, IAdditiveIdentity<T, TResult>, IAdditionOperators<T, TResult, TResult>
+		where TResult : INumber<TResult>
+	{
+		return list.FoldR(Add, TResult.Zero);
+	}
+
+	/// <summary>
+	/// Returns the product of the values contained in <paramref name="list"/>
+	/// </summary>
+	/// <param name="list">A <seealso cref="ListOf{T}"/> values to be summed</param>
+	/// <typeparam name="T"></typeparam>
+	/// <typeparam name="TResult"></typeparam>
+	/// <returns>The product of values held in <paramref name="list"/></returns>
+	public static TResult Product<T, TResult>(this ListOf<T> list)
+		where T : INumber<T>, IMultiplicativeIdentity<T, TResult>, IMultiplyOperators<T, TResult, TResult>
+		where TResult : INumber<TResult>
+	{
+		return list.FoldR(Mul, TResult.One);
+	}
+
+	/// <summary>
+	/// An addition function for use in <see cref="FoldR{T,TResult}"/> operations
+	/// </summary>
+	/// <param name="a">The first value</param>
+	/// <param name="b">The second value</param>
+	/// <typeparam name="T"></typeparam>
+	/// <typeparam name="TResult"></typeparam>
+	/// <returns>The summation of <paramref name="a"/> and <paramref name="b"/></returns>
+	private static TResult Add<T, TResult>(T a, TResult b)
+		where T : INumber<T>, IAdditiveIdentity<T, TResult>, IAdditionOperators<T, TResult, TResult>
+		where TResult : INumber<TResult>
+	{
+		return a + b;
+	}
+
+	/// <summary>
+	/// A multiplication function for use as a <see cref="FoldR{T,TResult}"/> operation
+	/// </summary>
+	/// <param name="a">The first value</param>
+	/// <param name="b">The second value</param>
+	/// <typeparam name="T"></typeparam>
+	/// <typeparam name="TResult"></typeparam>
+	/// <returns>The product of <paramref name="a"/> and <paramref name="b"/></returns>
+	private static TResult Mul<T, TResult>(T a, TResult b)
+		where T : INumber<T>, IMultiplicativeIdentity<T, TResult>, IMultiplyOperators<T, TResult, TResult>
+		where TResult : INumber<TResult>
+	{
+		return a * b;
+	}
+
+	/// <summary>
+	/// Provides a Fold-Right function to perform the required operation (<paramref name="fn"/>) on the <paramref name="list"/>, starting with the initial value <paramref name="initial"/>
+	/// </summary>
+	/// <param name="list">The <see cref="ListOf{T}"/> to be manipulated</param>
+	/// <param name="fn">The function manipulating the <paramref name="list"/></param>
+	/// <param name="initial">The initial value for the function</param>
+	/// <typeparam name="T"></typeparam>
+	/// <typeparam name="TResult"></typeparam>
+	/// <returns>The result of applying <paramref name="fn"/> over the <paramref name="list"/></returns>
+	private static TResult FoldR<T, TResult>(this ListOf<T> list, Func<T, TResult, TResult> fn, TResult initial)
+		where T : notnull
+		where TResult : notnull
+	{
+		return list.IsNil
+			? initial
+			: fn(list.Head, list.Tail.FoldR(fn, initial));
+	}
+
+	/// <summary>
+	/// Helper method to create a <see cref="ListOf{T}"/> from an array of values
+	/// </summary>
+	/// <param name="values">The values to be added to the output</param>
+	/// <typeparam name="T"></typeparam>
+	/// <returns>A <see cref="List{T}"/> object, containing all values in <paramref name="values"/></returns>
+	public static ListOf<T> BuildList<T>(this T[] values)
+		where T : notnull
+	{
+		return values.Length > 0
+			? ListOf<T>.Cons(values[0], BuildList(values[1..]))
+			: ListOf<T>.Nil();
+	}
+
+	/// <summary>
+	/// Provides a logical OR operation for two values
+	/// </summary>
+	/// <param name="a">The first value</param>
+	/// <param name="b">The second value</param>
+	/// <returns>The logical OR product</returns>
+	private static bool LogicalOr(bool a, bool b) => a || b;
+
+	/// <summary>
+	/// Provides a logical AND operation for two values
+	/// </summary>
+	/// <param name="a">The first value</param>
+	/// <param name="b">The second value</param>
+	/// <returns>The logical AND product</returns>
+	private static bool LogicalAnd(bool a, bool b) => a && b;
+
+	/// <summary>
+	/// Determines whether any of the <paramref name="values"/> are true
+	/// </summary>
+	/// <param name="values">A <see cref="ListOf{T}"/> object with boolean values</param>
+	/// <returns>True if any values are true, otherwise false</returns>
+	public static bool AnyTrue(ListOf<bool> values) => values.FoldR(LogicalOr, false);
+
+	/// <summary>
+	/// Determines whether ALL of the <paramref name="values"/> are true
+	/// </summary>
+	/// <param name="values">A <see cref="ListOf{T}"/> object with boolean values</param>
+	/// <returns>True if ALL values are true, otherwise false</returns>
+	public static bool AllTrue(ListOf<bool> values) => values.FoldR(LogicalAnd, true);
+
+	/// <summary>
+	/// Copies the contents of <paramref name="list"/> into a new <see cref="ListOf{T}"/>
+	/// </summary>
+	/// <param name="list">The list to be copied</param>
+	/// <typeparam name="T"></typeparam>
+	/// <returns>A copy of <paramref name="list"/></returns>
+	public static ListOf<T> Copy<T>(this ListOf<T> list)
+		where T : notnull
+	{
+		return list.FoldR(ListOf<T>.Cons, ListOf<T>.Nil());
+	}
+
+	/// <summary>
+	/// Appends the contents of <paramref name="second"/> to <paramref name="first"/>, returning a new <see cref="ListOf{T}"/>
+	/// </summary>
+	/// <param name="first">The first part of the <see cref="ListOf{T}"/></param>
+	/// <param name="second">The second part of the <see cref="ListOf{T}"/></param>
+	/// <typeparam name="T"></typeparam>
+	/// <returns>A new <see cref="ListOf{T}"/> object containing elements of both <paramref name="first"/> and <paramref name="second"/></returns>
+	public static ListOf<T> Append<T>(this ListOf<T> first, ListOf<T> second)
+		where T : notnull
+	{
+		return first.FoldR(ListOf<T>.Cons, second);
+	}
+
+	/// <summary>
+	/// Helper method to increment a counter for the length of a <see cref="ListOf{T}"/>
+	/// </summary>
+	/// <param name="left">N/A</param>
+	/// <param name="right">The counter value</param>
+	/// <typeparam name="T"></typeparam>
+	/// <returns>The incremented value of the counter</returns>
+	private static int Count<T>(T left, int right) => ++right;
+
+	/// <summary>
+	/// Determine the length of the <see cref="ListOf{T}"/>
+	/// </summary>
+	/// <param name="list">The object to be measured</param>
+	/// <typeparam name="T"></typeparam>
+	/// <returns>The number of objects in the <paramref name="list"/></returns>
+	public static int Length<T>(this ListOf<T> list) where T : notnull => list.FoldR(Count, 0);
+
+	/// <summary>
+	/// Helper method to return the double of <paramref name="value"/>
+	/// </summary>
+	/// <param name="value">The value to be doubled</param>
+	/// <typeparam name="T"></typeparam>
+	/// <returns>The equivalent of 2*<paramref name="value"/></returns>
+	private static T Double<T>(T value) where T : INumber<T> => value + value;
+
+	/// <summary>
+	/// Helper method to double the value of the current <see cref="ListOf{T}"/> object
+	/// </summary>
+	/// <param name="head">The value of the current <see cref="ListOf{T}.Head"/></param>
+	/// <param name="tail">The contents of the current <see cref="ListOf{T}.Tail"/></param>
+	/// <typeparam name="T"></typeparam>
+	/// <returns>A new instance of <see cref="ListOf{T}"/>, with the <see cref="ListOf{T}.Head"/> value doubled</returns>
+	private static ListOf<T> Double<T>(T head, ListOf<T> tail) where T : INumber<T> =>
+		ListOf<T>.Cons(Double(head), tail);
+
+	/// <summary>
+	/// A method to double the values contained within <paramref name="list"/> and return a new object
+	/// </summary>
+	/// <param name="list">The object to bew iterated over</param>
+	/// <typeparam name="T"></typeparam>
+	/// <returns>A new object with the contents of <paramref name="list"/>, with their respective <see cref="ListOf{T}.Head"/> values doubled</returns>
+	public static ListOf<T> DoubleAll<T>(this ListOf<T> list) where T : INumber<T> =>
+		list.FoldR(Double, ListOf<T>.Nil());
+
+	/// <summary>
+	/// A method to map the function <paramref name="fn"/> over the contents of <paramref name="list"/>, returning a new object
+	/// </summary>
+	/// <param name="list">The <see cref="ListOf{T}"/> to be manipulated</param>
+	/// <param name="fn">The function to manipulate the individual values</param>
+	/// <typeparam name="T"></typeparam>
+	/// <typeparam name="TResult"></typeparam>
+	/// <returns>The new object with manipulated values</returns>
+	private static ListOf<TResult> Map<T, TResult>(this ListOf<T> list, Func<T, TResult> fn)
+		where T : notnull
+		where TResult : notnull
+	{
+		return list.FoldR((head, tail) => ListOf<TResult>.Cons(fn(head), tail), ListOf<TResult>.Nil());
+	}
+
+	/// <summary>
+	/// A refactored method to double the values contained within <paramref name="list"/> and return a new object, using the <see cref="Map{T,TResult}"/> method
+	/// </summary>
+	/// <param name="list">The object to bew iterated over</param>
+	/// <typeparam name="T"></typeparam>
+	/// <returns>A new object with the contents of <paramref name="list"/>, with their respective <see cref="ListOf{T}.Head"/> values doubled</returns>
+	public static ListOf<T> DoubleAllEx<T>(this ListOf<T> list)
+		where T : INumber<T> => list.Map(Double);
+	
+	/// <summary>
+	/// Helper method to treble the input <paramref name="value"/>
+	/// </summary>
+	/// <param name="value">The value to be trebled</param>
+	/// <typeparam name="T"></typeparam>
+	/// <returns>The equivalent of 3*<paramref name=""/></returns>
+	private static T Triple<T>(T value) where T: INumber<T> => value + Double(value);
+
+	/// <summary>
+	/// Method to treble all <see cref="ListOf{T}.Head"/> values within <paramref name="list"/>, returning a new object
+	/// </summary>
+	/// <param name="list">The values to be trebled</param>
+	/// <typeparam name="T"></typeparam>
+	/// <returns>AQ new <see cref="ListOf{T}"/>, with <see cref="ListOf{T}.Head"/> values which are triple the original</returns>
+	public static ListOf<T> TripleAll<T>(this ListOf<T> list)
+		where T : INumber<T> => list.Map(Triple);
+}
\ No newline at end of file
diff --git a/Mark-CSharp/WhyFunctional/Program.cs b/Mark-CSharp/WhyFunctional/Program.cs
new file mode 100644
index 0000000..ba5ab49
--- /dev/null
+++ b/Mark-CSharp/WhyFunctional/Program.cs
@@ -0,0 +1,9 @@
+namespace WhyFunctional;
+
+internal static class Program
+{
+    public static void Main(string[] args)
+    {
+        Console.WriteLine("Hello, World!");
+    }
+}
diff --git a/Mark-CSharp/WhyFunctional/WhyFunctional.csproj b/Mark-CSharp/WhyFunctional/WhyFunctional.csproj
new file mode 100644
index 0000000..206b89a
--- /dev/null
+++ b/Mark-CSharp/WhyFunctional/WhyFunctional.csproj
@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>