Optional.swift

enum 📦<Value> {
    case 😺(Value)
    case 😵
    
    init(_ from: Value) {
        self = .😺(from)
    }
}

extension 📦: ExpressibleByNilLiteral {
    init(nilLiteral: ()) {
        self = .😵
    }
}

postfix operator ❓
postfix func ❓<T>(value: T) -> 📦<T> {
    .😺(value)
}

postfix operator ❗
postfix func ❗<T>(value: 📦<T>) -> T {
    switch value {
    case .😺(let v):
        return v
    case .😵:
        fatalError("Cat is dead Bruh!")
    }
}

infix operator ❓➡️: NilCoalescingPrecedence
func ❓➡️<T>(lhs: 📦<T>, rhs: @autoclosure () -> T) -> T {
    switch lhs {
    case .😺(let value):
        return value
    case .😵:
        return rhs()
    }
}

@dynamicMemberLookup
struct _📦<Value> {
    private let storage: 📦<Value>

    init(from: 📦<Value>) {
        storage = from
    }
    
    subscript<T>(dynamicMember keyPath: KeyPath<Value, 📦<T>>) -> 📦<T> {
        switch storage {
        case .😺(let v):
            return v[keyPath: keyPath]
        case .😵:
            return .😵
        }
    }
}

postfix operator ❔
postfix func ❔<T>(value: 📦<T>) -> _📦<T> {
    return _📦(from: value)
}