What is better syntax with chain if else in swift

I would like to write a function that execute couple of subset function based on return value of subset function. The logic is
if funcA is successfully executed return
Otherwise executes funcB
if funcB is successfully executed return
Otherwise executes funcC
I have followed snippet but wondering if any better syntax in swift?

func funcA() -> Bool {
    // Implementation of funcA goes here
    // Replace this with your actual logic for funcA
    return true // Replace 'true' with the actual result of funcA
}

func funcB() -> Bool {
    // Implementation of funcB goes here
    // Replace this with your actual logic for funcB
    return false // Replace 'false' with the actual result of funcB
}

func funcC() {
    // Implementation of funcC goes here
    // Replace this with your actual logic for funcC
    print("Function C executed")
}

func performLogic() {
    let resultA = funcA()
    
    if resultA {
        return // Return early if resultA is true
    }
    
    let resultB = funcB()
    
    if !resultB {
        funcC()
    }
}

performLogic()

To be honest, your current code is very readable and I don't think it needs a "better" syntax. You can make the syntax shorter, but that would make it less readable.

For example, you can do (assuming you don't need the intermediate results):

if !funcA() && !funcB() {
    funcC()
}

This takes advantage of the fact that && is lazy.

If you can change the return types of the functions, then changing funcC to also return a Bool allows you to do:

funcA() || funcB() || funcC()

Alternatively, change them all to return a Void?. Return nil when it is not successful, and return () otherwise. This allows you to use the ?? operator, which is a common idiom to provide a "default" when something fails

funcA() ?? funcB() ?? funcC()

That said, returning Void? looks quite weird. If the functions actually return some meaningful value, then I would recommend doing it this way.

I would use locally scoped variables only when really needed. This approach reduces complexity and can make the code cleaner. If the functions are named meaningfully, using locally scoped variables might not be necessary at all.

Implementing early returns in Swift, typically a guard is used.

func performLogic() {
    guard !funcA() else { return }
    guard funcB() else { return }

    funcC()
}

Better to use guard_1 or guard_2

func funcA() -> Bool {
    // Implementation of funcA goes here
    // Replace this with your actual logic for funcA
    return true // Replace 'true' with the actual result of funcA
}

func funcB() -> Bool {
    // Implementation of funcB goes here
    // Replace this with your actual logic for funcB
    return false // Replace 'false' with the actual result of funcB
}

func funcC() {
    // Implementation of funcC goes here
    // Replace this with your actual logic for funcC
    print("Function C executed")
}

func performLogic() {
    guard funcA() else {
        return // Return early if resultA is true
    }
    
    guard !funcB() else {
        funcC()
        return
    }
}

performLogic()