Optional

A type-safe implementation of the Optional pattern

In One Line

Null? not Null? Never Matter!

Overview

A type-safe implementation of the Optional pattern, providing elegant null handling and functional programming features for both reference and value types.

The system provides two main structures:

• Option<T> for reference types

• ValueOption<T> for value types

Please read java official document about Optional.

---

Package Info

display name	AceLand Optional
package name	com.aceland.optional
latest version	1.0.0
namespace	AceLand.Optional
git repository	https://github.com/parsue/com.aceland.optional.git
dependencies

---

How It Works

// reference types
Player player = GetPlayer();
Option<Player> playerOption = player.ToOption();

// value types
int score = 100;
ValueOption<int> scoreOption = score.ToValueOption();

// safe access
if (playerOption.IsPresent())
{
    var player = playerOption.Get();
    // Work with player
}

// mapping
Option<string> playerName = playerOption
    .Map(p => p.Name);

// chaining with condition
Option<Player> activePlayer = playerOption
    .Where(p => p.IsActive)
    .Reduce(p => UpdatePlayer(p));

// default values
Player fallbackPlayer = playerOption
    .Reduce(() => CreateDefaultPlayer());

Key Features

• Type-safe null handling

• Functional programming support (Map, Where, Reduce)

• Seamless conversion between reference and value types

• Fluent interface for method chaining

• Extension methods for convenient usage

• Full equality comparison support

The system helps eliminate null reference exceptions while providing a clean, functional approach to handling optional values in Unity development.

---

Create

• Option<T> where T : class

• ValueOption<T> where T : struct

// getting nullable result from server
string name = GetNameFromServer();
int id = GetIdFromServer();

// convert from existing type
Option<string> optionalName = name.ToValueOption();
ValueOption<int> optionalId = id.ToOption();

// create by constructor with value
Option<string> optionalName = Option<string>.Some(name);
ValueOption<int> optionalId = ValueOption<int>.Some(id);

// create by constructor with null
Option<string> optionalId = Option<string>.None();
ValueOption<int> optionalId = ValueOption<int>.None();

Get Value

• same usage to Option<T> and ValueOption<T>

// Check null
bool isNull = optionalName.IsPresent();

// Get: return value without null handling
string nameOrNull = optionalName.Get();

// Reduce: return given value if null, overwise return current value
string userName = optionalName.Reduce(Guid.NewGuid().ToString());
int userId = optionalId.Reduce(CreateIdFromServer());

// Where and WhereNot condition
// reture Option<T> or Option<T>.None()
Option<string> optionalNextName = optionalName.Where(name =>
    Check(name));
ValueOption<int> optionalUserId = optionalId.WhereNot(id =>
    Check(id));
ValueOption<int> optionalUserId = optionalId.Where(id =>
    Check(id));
Option<string> optionalNextName = optionalName.WhereNot(name =>
    Check(name));

// Map new type and value,
// returning new Option<T> or ValueOption<T>
Option<UserName> optionalUserName = optionalName.Map<UserName>(name =>
    new UserName(name));
ValueOption<UserId> optionalUserId = optionalId.MapValue(id =>
    new UserId(id));

---