I created a custom type which enables me to have enums which have as their initial state, the init value of their base type. Something similiar to Nullable...

enum Reason : string {CO = "Co", FU = "Fu", CA = "Ca"}
struct TestStruct {InitialEnum!Reason reason;}

This line raises the error:
TestStruct s2 = TestStruct(Reason.FU);
>> Error: cannot implicitly convert expression ("Fu") of type Reason to InitialEnum!(Reason)

While this line is working fine:
TestStruct s1 = {reason: Reason.FU};

I asked this question in the learning forum and got the advice to create an issue.

struct InitialEnum(T)
{
	import std.traits: OriginalType, EnumMembers;
	import std.conv: to;
	
	private T _value;
	private bool _isEmpty = true;
	alias EnumBaseType = OriginalType!T;
	
	@property EnumBaseType baseTypeValue() { return (_isEmpty) ? EnumBaseType.init : _value; }
	@property T value()	{ return _value; }
	@property bool isEmpty() { return _isEmpty;	}
	
	alias baseTypeValue this;
	
	void opAssign(EnumBaseType value)
	{
		if (value == EnumBaseType.init)
		{
			_isEmpty = true;
			return;
		}
		
		foreach (member; EnumMembers!T)
		{
			if (value == member)
			{
				_value = member;
				_isEmpty = false;
				return;
			}		
		}
		throw new Exception("Value "~value.to!string~" is not a valid enum value");
	}

	this(T t)
	{
		_isEmpty = false;
		_value = t;
	}
	
	this(EnumBaseType value)
	{
		opAssign(value);
	}
}