enhanced project file, full public api commented

Author: pimbrouwers

README.md

@@ -230,7 +230,7 @@ public ResultOption<int, string> GetUserId(string username)
         none: ResultOption<int, string>.None);
 
     // or, using the extension method
-    LookupUserId(username).ToResultOption();
+    // return LookupUserId(username).ToResultOption();
 }
 ```
 

src/Danom/Danom.csproj

@@ -1,9 +1,38 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
+    <AssemblyName>Danom</AssemblyName>
+    <Version>1.0.0-alpha1</Version>
+
+    <!-- General info -->
+    <Description>Monadic structures to simplify functional programming patterns in C#.</Description>
+    <Copyright>Copyright 2024 Pim Brouwers</Copyright>
+    <Authors>Pim Brouwers</Authors>
+    <NeutralLanguage>en-CA</NeutralLanguage>
+
+    <!-- Build config -->
     <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+    <DebugType>embedded</DebugType>
+    <OutputType>Library</OutputType>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+
+    <!-- NuGet config -->
+    <PackageId>Danom</PackageId>
+    <PackageTags>fsharp;functional;database;sql;ado;adonet</PackageTags>
+    <PackageProjectUrl>https://github.com/pimbrouwers/Danom</PackageProjectUrl>
+    <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
+    <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
+    <RepositoryType>git</RepositoryType>
+    <RepositoryUrl>https://github.com/pimbrouwers/Danom</RepositoryUrl>
+
+    <!-- SourceLink settings -->
+    <PublishRepositoryUrl>true</PublishRepositoryUrl>
+    <EmbedUntrackedSources>true</EmbedUntrackedSources>
+    <IncludeSymbols>true</IncludeSymbols>
   </PropertyGroup>
 
 </Project>

src/Danom/Option/Option.cs

@@ -104,7 +104,7 @@ public Option<T> OrElseWith(
     /// <param name="value"></param>
     /// <returns></returns>
     public static Option<T> Some(T value) =>
-        new Option<T>(value);
+        new(value);
 
     /// <summary>
     /// Creates Option with the specified value wrapped in a completed Task.
@@ -127,7 +127,7 @@ public static async Task<Option<T>> SomeAsync(Task<T> value) =>
     /// </summary>
     /// <returns></returns>
     public static Option<T> None() =>
-        new Option<T>();
+        new();
 
     /// <summary>
     /// Creates a new Option with no value wrapped in a completed Task.
@@ -136,15 +136,37 @@ public static Option<T> None() =>
     public static Task<Option<T>> NoneAsync() =>
         Task.FromResult(None());
 
+    /// <summary>
+    /// Returns true if the specified Options are equal.
+    /// </summary>
+    /// <param name="left"></param>
+    /// <param name="right"></param>
+    /// <returns></returns>
     public static bool operator ==(Option<T> left, Option<T> right) =>
         left.Equals(right);
 
+    /// <summary>
+    /// Returns true if the specified Options are not equal.
+    /// </summary>
+    /// <param name="left"></param>
+    /// <param name="right"></param>
+    /// <returns></returns>
     public static bool operator !=(Option<T> left, Option<T> right) =>
         !(left == right);
 
+    /// <summary>
+    /// Returns true if the specified Options are equal.
+    /// </summary>
+    /// <param name="obj"></param>
+    /// <returns></returns>
     public override bool Equals(object? obj) =>
         obj is Option<T> o && Equals(o);
 
+    /// <summary>
+    /// Returns true if the specified Options are equal.
+    /// </summary>
+    /// <param name="other"></param>
+    /// <returns></returns>
     public readonly bool Equals(Option<T> other) =>
         Match(
             some: x1 =>
@@ -157,11 +179,19 @@ public readonly bool Equals(Option<T> other) =>
                     none: () => true)
             );
 
+    /// <summary>
+    /// Returns the hash code of the Option.
+    /// </summary>
+    /// <returns></returns>
     public override int GetHashCode() =>
         Match(
             some: x => x is null ? 0 : x.GetHashCode(),
             none: () => 0);
 
+    /// <summary>
+    /// Returns the string representation of the Option.
+    /// </summary>
+    /// <returns></returns>
     public override string ToString() =>
         Match(
             some: x => $"Some({x})",

src/Danom/Result/Result.cs

@@ -70,8 +70,8 @@ public Result<U, TError> Map<U>(
     /// <summary>
     /// Evaluates the mapError delegate if Result is Error otherwise return Ok.
     /// </summary>
-    /// <typeparam name="U"></typeparam>
-    /// <param name="map"></param>
+    /// <typeparam name="UError"></typeparam>
+    /// <param name="mapError"></param>
     /// <returns></returns>
     public Result<T, UError> MapError<UError>(
         Func<TError, UError> mapError) =>
@@ -144,15 +144,37 @@ public static Task<Result<T, TError>> ErrorAsync(TError errors) =>
     public static async Task<Result<T, TError>> ErrorAsync(Task<TError> errors) =>
         Error(await errors);
 
+    /// <summary>
+    /// Returns true if the specified Result is equal to the current Result.
+    /// </summary>
+    /// <param name="left"></param>
+    /// <param name="right"></param>
+    /// <returns></returns>
     public static bool operator ==(Result<T, TError> left, Result<T, TError> right) =>
         left.Equals(right);
 
+    /// <summary>
+    /// Returns true if the specified Result is not equal to the current Result.
+    /// </summary>
+    /// <param name="left"></param>
+    /// <param name="right"></param>
+    /// <returns></returns>
     public static bool operator !=(Result<T, TError> left, Result<T, TError> right) =>
         !(left == right);
 
+    /// <summary>
+    /// Returns true if the specified Result is equal to the current Result.
+    /// </summary>
+    /// <param name="obj"></param>
+    /// <returns></returns>
     public override bool Equals(object? obj) =>
         obj is Result<T, TError> o && Equals(o);
 
+    /// <summary>
+    /// Returns true if the specified Result is equal to the current Result.
+    /// </summary>
+    /// <param name="other"></param>
+    /// <returns></returns>
     public readonly bool Equals(Result<T, TError> other) =>
         Match(
             ok: x1 =>
@@ -164,13 +186,96 @@ public readonly bool Equals(Result<T, TError> other) =>
                     ok: _ => false,
                     error: e2 => e2 is not null && e2.Equals(e1)));
 
+    /// <summary>
+    /// Returns the hash code for the Result.
+    /// </summary>
+    /// <returns></returns>
     public override int GetHashCode() =>
         Match(
             ok: x => x is null ? 0 : x.GetHashCode(),
             error: e => e is null ? 0 : e.GetHashCode());
 
+    /// <summary>
+    /// Returns a string representation of the Result.
+    /// </summary>
+    /// <returns></returns>
     public override string ToString() =>
         Match(
             ok: x => $"Ok({x})",
             error: e => $"Error({e})");
 }
+
+
+/// <summary>
+/// The <see cref="Result{T, TError}"/> with <see cref="ResultErrors"/>
+/// as the predefined error type.
+///
+/// Alias for <see cref="Result{T, ResultErrors}"/>.
+/// </summary>
+/// <typeparam name="T"></typeparam>
+public static class Result<T>
+{
+    /// <summary>
+    /// Creates a new Result with the specified value.
+    /// </summary>
+    /// <param name="value"></param>
+    /// <returns></returns>
+    public static Result<T, ResultErrors> Ok(T value) =>
+        Result<T, ResultErrors>.Ok(value);
+
+    /// <summary>
+    /// Creates Result with the specified value wrapped in a completed Task.
+    /// </summary>
+    /// <param name="value"></param>
+    /// <returns></returns>
+    public static Task<Result<T, ResultErrors>> OkAsync(T value) =>
+        Result<T, ResultErrors>.OkAsync(value);
+
+    /// <summary>
+    /// Creates Result with the value of the awaited Task.
+    /// </summary>
+    /// <param name="valueTask"></param>
+    /// <returns></returns>
+    public static Task<Result<T, ResultErrors>> OkAsync(Task<T> valueTask) =>
+        Result<T, ResultErrors>.OkAsync(valueTask);
+
+    /// <summary>
+    /// Creates a new Result with the specified error.
+    /// </summary>
+    /// <param name="errors"></param>
+    /// <returns></returns>
+    public static Result<T, ResultErrors> Error(ResultErrors errors) =>
+        Result<T, ResultErrors>.Error(errors);
+
+    /// <summary>
+    /// Creates Result with the specified error wrapped in a completed Task.
+    /// </summary>
+    /// <param name="errors"></param>
+    /// <returns></returns>
+    public static Task<Result<T, ResultErrors>> ErrorAsync(ResultErrors errors) =>
+        Task.FromResult(Error(errors));
+
+    /// <summary>
+    /// Creates a new Result with the specified error.
+    /// </summary>
+    /// <param name="messages"></param>
+    /// <returns></returns>
+    public static Result<T, ResultErrors> Error(IEnumerable<string> messages) =>
+        Error(new ResultErrors(messages));
+
+    /// <summary>
+    /// Creates Result with the specified error wrapped in a completed Task.
+    /// </summary>
+    /// <param name="message"></param>
+    /// <returns></returns>
+    public static Result<T, ResultErrors> Error(string message) =>
+        Error([message]);
+
+    /// <summary>
+    /// Creates Result with the specified error wrapped in a completed Task.
+    /// </summary>
+    /// <param name="message"></param>
+    /// <returns></returns>
+    public static Task<Result<T, ResultErrors>> ErrorAsync(string message) =>
+        Task.FromResult(Error(message));
+}