ezura

public class Lazy<T> {
    private let initializer: () -> T
    
    private var _value: T!
    public var value: T {
        get {
            // TODO: mutex
            switch _value {
            case .none:
                _value = initializer()

ezura

// goal: call `(Never instance).foo()`
extension Never {
    func foo() { print("exec") }
}

unsafeBitCast((), to: Never.self).foo() // print "exec"
(nil as Never?)?.foo() // ()?
fatalError().foo() // runtime error

ezura

precedencegroup GroupA {

    associativity: none
}
precedencegroup GroupB {

    higherThan: GroupA
    associativity: none
}

ezura

func f() {
    defer {
        print("defer") /* <- ② */
    }
    return /* <- ③ */ print("return value") /* <- ① */
}

class C {
    var v: () {
        get { }

ezura

switch "" as Optional {
case _:
    print("_")
case _?:  // ⚠️ Case will never be executed
    print("_?")
//case _??: // ❗️error: '?' pattern cannot match values of type 'String'
//    print("_??")
default:
    print("s")
}

ezura

switch "" as Optional {
case _?:
    print("_?")
default:
    print("s")
}

ezura

var p: Protocol

ezura

extension Optional: CustomStringConvertible {
    public var description: String {
        switch self {
        case .none:
            return ""
        case .some(let wrapped):
            return "\(wrapped)"
        }
    }
}

ezura

"\(Normal() as Optional)"
// -> "Optional(description)"

"\(Force() as Optional)"
// -> "description"


// ------------------
struct Normal: CustomStringConvertible {
    var description: String { return "\(#function)" }

ezura

let any: Any = 🍎()

if let any = any as? 🌳 {
    // do something
}

// -----------

if case let any as 🌳 = any {
    // do something