class Foo {
  func bar() -> Int { print("result matters"; return 0 }

  @discardableResult
  func bar() -> Int { print("result is forgotten"); return 1 }
}

let x = Foo().bar() // prints: result matters
Foo().bar()       // prints: result is forgotten

protocol P1 {
    func then() -> Self
}

protocol P2 {
    @discardableResult
    func then() -> Self
}

class A1 {
    @discardableResult
    func then() -> A1 {
        return A1()
    }
}

final class C: A1, P1, P2 {
    override func then() -> C {
        return C()
    }
}

let p1: P1 = C()
let p2: P2 = C()
let a1: A1 = C()
let c : C  = C()

// actually that's how it works. How shall it works after the fix?
p1.then() // warns
p2.then() // silent
a1.then() // silent
c .then() // warns

class Promise<T> {
    init(_ arg: T) {}
    
    func then(closure: () -> T) -> Promise<T> {
        return Promise<T>(closure())
    }
    
    func `catch`() {}
}

class UnfailablePromise<T>: Promise<T> {
    @discardableResult
    override func then(closure: () -> T) -> UnfailablePromise<T> {
        return UnfailablePromise<T>(closure())
    }
}


Promise<Int>(0).then(closure: { 5 }) // warns (the intention is to force user to use `catch`)
Promise<Int>(0).then(closure: { 5 }).catch() // potential error caught, no warning
UnfailablePromise<Int>(0).then(closure: { 5 }) // no warning, since promise can't fail