dotUnit 1.0.0

dotUnit

dotUnit is an ultra-lightweight C# library that provides a Unit type. Its purpose is to serve as a functional programming equivalent for void, enabling more consistent and composable code, especially in generic contexts.

Why dotUnit?

In C#, void is a keyword, not a type. This creates limitations when working with generic types like Task<T> or custom functional constructs like Result<TSuccess, TError>. You cannot use void as a generic type argument:

// This is not valid C# code
Task<void> DoSomethingAsync(); 
Result<void, Error> DoSomething();

The common workaround is to use an empty, meaningless struct. dotUnit formalizes this concept by providing a standardized, explicit Unit type, signaling that a method is executed for its side effect, returning no meaningful value.

Using Unit makes your intentions clear and allows "void" methods to be first-class citizens in your functional code.

• Task<Unit> vs Task: Task<Unit> is more explicit and composable in functional chains.

• Result<Unit, Error>: Clearly represents a successful operation that produces no value.

This package is inspired by the unit type found in functional languages like F# and Haskell.

Installation You can install dotUnit via the .NET CLI:

dotnet add package dotUnit

Or via the NuGet Package Manager:

Install-Package dotUnit

How to Use

Simply return Unit.Instance from any method that would otherwise return void.

Basic Example Instead of this:

public void LogMessage(string message)
{
    Console.WriteLine(message);
}

You can write this:

using DotUnit;

public Unit LogMessage(string message)
{
    Console.WriteLine(message);
    return Unit.Instance;
}

Asynchronous Example

Using Task<Unit> makes asynchronous workflows that don't return a value more composable.

using DotUnit;
using System.Threading.Tasks;

public async Task<Unit> UpdateCacheAsync()
{
    // Perform some async work...
    await Task.Delay(100); 
    
    Console.WriteLine("Cache updated.");
    
    return Unit.Instance;
}

With a Result Type dotUnit works perfectly with functional constructs like a Result monad (for example, with a library like dotResult).

// Assuming you have a Result<TSuccess, TError> type
using DotUnit;

public Result<Unit, string> SaveUser(User user)
{
    try
    {
        // Save user to database...
        return Result<Unit, string>.Success(Unit.Instance);
    }
    catch (Exception ex)
    {
        return Result<Unit, string>.Failure("Failed to save user.");
    }
}

License

This project is licensed under the MIT License.