Optional.cs

using System;
using UnityEngine;

[Serializable]
/// Requires Unity 2020.1+
public struct Optional<T>
{
    [SerializeField] private bool enabled;
    [SerializeField] private T value;

    public bool Enabled => enabled;
    public T Value => value;

    public Optional(T initialValue)
    {
        enabled = true;
        value = initialValue;
    }
}

OptionalPropertyDrawer.cs

using UnityEditor;
using UnityEngine;

namespace Editor
{
    [CustomPropertyDrawer(typeof(Optional<>))]
    public class OptionalPropertyDrawer : PropertyDrawer
    {
        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
        {
            var valueProperty = property.FindPropertyRelative("value");
            return EditorGUI.GetPropertyHeight(valueProperty);
        }

        public override void OnGUI(
            Rect position,
            SerializedProperty property,
            GUIContent label
        )
        {
            var valueProperty = property.FindPropertyRelative("value");
            var enabledProperty = property.FindPropertyRelative("enabled");

            EditorGUI.BeginProperty(position, label, property);
            position.width -= 24;
            EditorGUI.BeginDisabledGroup(!enabledProperty.boolValue);
            EditorGUI.PropertyField(position, valueProperty, label, true);
            EditorGUI.EndDisabledGroup();

            int indent = EditorGUI.indentLevel;
            EditorGUI.indentLevel = 0;
            position.x += position.width + 24;
            position.width = position.height = EditorGUI.GetPropertyHeight(enabledProperty);
            position.x -= position.width;
            EditorGUI.PropertyField(position, enabledProperty, GUIContent.none);
            EditorGUI.indentLevel = indent;
            EditorGUI.EndProperty();
        }
    }
}

Hi, I did make a custom editor for this Optional which also support passing attributes down to the "T value".
Just want to share this to the community.
Oh, you also need to have Odin Inspector packet

Here are some examples.

OptionalAttributeProcessor.cs

using System.Collections.Generic;
using System.Reflection;
using Newtonsoft.Json;
using Sirenix.OdinInspector;
using Sirenix.OdinInspector.Editor;
using UnityEngine;

namespace Maniac.Utils.Editor
{
    public class OptionalAttributeProcessor<T> : OdinAttributeProcessor<Optional<T>>
    {
        private static readonly List<Type> KeepAttributeTypes = new List<Type>
        {
            typeof(SerializeField),
            typeof(SerializableAttribute),
            typeof(HeaderAttribute),
            typeof(InfoBoxAttribute),
            typeof(JsonIgnoreAttribute),
        };

        private List<Attribute> parentAttributesToPassDown = new List<Attribute>();
        public override void ProcessSelfAttributes(InspectorProperty property, List<Attribute> attributes)
        {
            // Store attributes to pass down
            parentAttributesToPassDown.Clear();
            foreach (var attribute in attributes)
            {
                if (!KeepAttributeTypes.Contains(attribute.GetType()))
                {
                    parentAttributesToPassDown.Add(attribute);
                }
            }

            // Remove attributes that are not to be kept on the parent
            attributes.RemoveAll(attr => !KeepAttributeTypes.Contains(attr.GetType()));
            
            base.ProcessSelfAttributes(property, attributes);
        }

        public override void ProcessChildMemberAttributes(InspectorProperty parentProperty, MemberInfo member, List<Attribute> attributes)
        {
            // If the member is the 'value' field of the Optional<T> class, propagate selected attributes to it
            if (member.Name == "value")
            {
                attributes.AddRange(parentAttributesToPassDown);
            }
            
            base.ProcessChildMemberAttributes(parentProperty,member, attributes);
        }
    }
}

OptionalDrawer.cs

using Sirenix.OdinInspector.Editor;
using Sirenix.Utilities;
using Sirenix.Utilities.Editor;
using UnityEditor;
using UnityEngine;

namespace Maniac.Utils.Editor
{
    public class OptionalDrawer<T> : OdinValueDrawer<Optional<T>>
    {
        private PropertyTree propertyTree;
        private readonly string enabledLabel = nameof(Optional<T>.Enabled).AddColor(Color.cyan);
        private readonly string disabledLabel = nameof(Optional<T>.Enabled).AddColor(Color.black);

        protected override void DrawPropertyLayout(GUIContent label)
        {
            var valueEntry = this.ValueEntry;
            var optional = valueEntry.SmartValue;

            EditorGUILayout.BeginVertical(GUI.skin.box);
            {
                EditorGUILayout.BeginHorizontal();
                {
                    EditorGUILayout.LabelField(label.AddColor(Color.white), new GUIStyle
                    {
                        alignment = TextAnchor.MiddleLeft,
                        richText = true
                    });
                    GUILayout.FlexibleSpace();
                    var correctLabel = optional.Enabled ? enabledLabel : disabledLabel;
                    var userClicked = GUILayout.Button(correctLabel, new GUIStyle(GUI.skin.button)
                    {
                        richText = true
                    });
                    if (userClicked)
                    {
                        optional.Enabled = !optional.Enabled;
                    }
                }
                EditorGUILayout.EndHorizontal();

                if (optional.Enabled)
                {
                    var valueProperty = GetValueChildren(valueEntry.Property);
                    if (valueProperty == null)
                    {
                        SirenixEditorGUI.WarningMessageBox($"Cannot find value in {valueEntry.Property}. Please ensure that it's serializable!");
                    }
                    else
                    {
                        EditorGUILayout.BeginVertical(GUI.skin.box);
                        {
                            var childLabel = valueProperty.Label;
                            childLabel.text = string.Empty;
                            valueProperty.Draw(childLabel);
                        }
                        EditorGUILayout.EndVertical();
                    }
                }
            }
            EditorGUILayout.EndVertical();

            valueEntry.SmartValue = optional;
        }

        private InspectorProperty GetValueChildren(InspectorProperty parent)
        {
            foreach (var child in parent.Children)
            {
                if (child.Name == "value")
                {
                    return child;
                }
            }
            return null;
        }
    }
    
    public static class Extension
    {
        private static readonly string colorFormat = "<color={1}>{0}</color>";

        public static string AddColor(this object origin, string colorInHex)
        {
            return string.Format(colorFormat, origin.ToString(), colorInHex);
        }
        
        public static string AddColor(this object origin, Color color)
        {
            return string.Format(colorFormat, origin.ToString(), ToRGBHex(color));
        }
        
        public static string ToRGBHex(Color c)
        {
            return $"#{ToByte(c.r):X2}{ToByte(c.g):X2}{ToByte(c.b):X2}";
        }
        
        private static byte ToByte(float f)
        {
            f = Mathf.Clamp01(f);
            return (byte)(f * 255);
        }
    }
}