Early Returning Functions

Returning values and objects from a function are one of the core programming concepts found in almost every language. A Functional Programming language is a center around the concept of pure functions. A pure function is a function that produces the same output given the same input and hence doesn’t generate any side effects or misbehaves.

Let us see how to use the concept of Functional programming to improve the readability of code, and the current project makes it more robust by using the concept of early return functions in the iPhone app development services.

Return early, whenever possible

Let’s start by looking at an example. Suppose we need to get a surname according to the first name. In the below-implemented method getSurnameFrom(firstName:), we fetch the surname by passing the first name as a parameter.

func getSurnameFrom(firstName: String?) -> String { var surName: String if let firstName = firstName { switch firstName { case "Alex": surName = "Dyson" case "Joshua": surName = "Joyce" case "James": surName = "Savoy" default: surName = "" } } else { surName = "" } return surName }

The method works fine. There is technically nothing wrong with it. But the same thing can be implemented in a better way.

Have a look at another implementation.

func getSurnameFrom(firstName: String?) -> String { guard let firstName = firstName else { return "" } switch firstName { case "Alex": return "Dyson" case "Joshua": return "Joyce" case "James": return "Savoy" default: return "" } }

This function also performs the same job. But look at the return statements. We first check if first Name property contains a value or not. If it contains value we proceed further else the function returns an empty string from this point only, avoiding further code execution. Same applies for every case in the switch. If the first name is "Alex", "Dyson" is returned from this point only. If the first name is "Joshua", "Joyce" is returned. Same goes for "James".

We are checking the condition and returning the value as soon as it matches the condition. Adopting this approach lets you focus more on getting the final result, making it more optimized and cleaner down the road.

By employing the return early approach, the code becomes cleaner and robust. It is more readable and more understandable as well. It is very clear on which condition what code will execute. One won’t have to remember the previous condition as it is now straightforward. The chances of getting wrong logic and introducing bugs here are much lower than the previous implementation, being the code is more perceptible and much more clear and to the point.

Conclusion:

The pattern is called return early pattern because it recommends that a function should return early as possible avoiding further code execution. It makes the code more declarative. If one wants to modify the code later or add more cases or the complexity of the code increases, one can easily wrap each alternative in a new method and make them call accordingly maintaining the declarative style.

With functions, conditional unwrapping and early return statements, one can well structure the code. It helps in structuring the code more as pure functions with clear statements and conditions. And a well-structured code is easier to test, maintain and debug.