Easy iOS Application Development Using Top 5 Swift 5.4 Features

This article will take you on the run through the new Swift 5.4 Features to help you during the iOS App development process and make it easier. These features have been proved very powerful and valuable at the same time. Swift parts feel just like an Apple Pie.

There is a reason why people choose the Apple Gadgets rather than trying other technology because Apple provides durability, exquisite features, user-friendly, extreme security, good resale values, and faster usage. It is like an all in one package that will benefit you in many ways. Well, there is another competitor technology that is here to compete with Apple, i.e. Android. 

Apple is famous because it comes with the latest and the finest usability available in the market. So, a new version of Swift 5.0 came in in March 2019. This new version brought many changes in the process of iOS App development up until now. The process became much easier, and the work just got better and more efficient. People switch their iPhones like they switch Instagram Reels these days. Whenever the new iPhone launches, the sales of the product reach a peak. According to The Verge, there are now over 1.65 billion active iPhone users. 

Today, we will look at some of the most significant changes that came with Swift 5.0 and how it became the best choice for every single iOS app developer in the world. In 2019, when Swift 5.0 came out in the market, its features are all that mattered. This new version led to the development in Swift’s server-side to use it as a back-end language for web services. 

But what is the point of understanding all this? 

If you don’t know why we’re doing this, you need to realise that Swift is way too strong than creating any iOS app. Let’s take a look at the attribute of both. 

Why choose Swift 5.4 for business? 

Swift 5.4’s main libraries were integrated into iOS, macOS, watchOS, and tvOS updates after its release. As a result of the provided libraries, apps produced for these platforms can now be more minor. Apple can also provide cross-platform support thanks to the reliable application binary interface. Nonetheless, because Apple continues to support Objective-C, many developers are faced with a decision.

Swift 5.4 is much preferable for business because: 

• Swift is easy to read
• Interactive and collaborative code
• Safer to use
• Easier to maintain
• Unification with memory management 
• The cutting-edge error handling model 
• Updated, New and reliable syntax features 

Best Swift 5.4 Features

The Apple ecosystem’s preferred programming language is Swift. It’s a secure, fast, and engaging option that combines the best of Apple’s engineering culture with open-source contributions.

Swift 5.4 offers some of the best features, making it easy for developers to build the best iOS app. 

#1 Multiple Variadic Parameter

A good change was introduced by SE-0284 when Swift 5.4 entered the market. The ability was to have subscripts, initialisers, and functions that use multiple variadic parameters have labels. Before Swift 5.4 came out, you could only have one parameter for some times like this. 

Let’s have a look at before and after multiple variadic parameters came in. 

Before: 

func method(singleVariadicParameter: String) {}

After Swift 5.4, when you can use multiple variadic parameter 

func method(multipleVariadicParameter: String..., secondMultipleVariadicParameter: String...) {}

Here, we can call the function on what we wrote above, but obviously, you can just write a single String element if you wish. 

Have a look at the code.  

method(multipleVariadicParameter: "You", "are", "firstborn", secondmultipleVariadicParameter: "Eve", "Adam")

Multiple variadic parameters work exactly like arrays. Of course, it is vital to check whether a value in a parameter exists before calling it; otherwise, the call would be incorrect and crash. The code is as follows:

func chooseSecondPerson(persons: String...) -> String {
   let index = 1
   if persons.count > index {
       return persons[index]
   } else {
       return "There is no second person."
   }
}

#2 Result Builder 

In Swift 5.1, the function builder was present unofficially, but in the run, till reaching Swift 5.4, they went through the Swift Evolution process as SE-0289 to redefine and discuss. 

Moreover, they were renamed result builders as part of the process to represent their actual role better, and some additional functionality was added. 

Moreover, result builders allow us to incrementally produce a new value by passing in a sequence of our choosing. When we have a VStack with various views, Swift discreetly bundles them together into an internal TupleView type to be stored as a single child of the VStack – it converts a succession of opinions into a single view.

If you wish, you can write so many codes at a times, and Result Builder can take more than the whole article, but the least we can do is give a gist so you can understand it better and see them in action. 

func makeSentence1() -> String {
    "Where does the universe end? How big is the universe?"
}

print(makeSentence1())

That will work out well for you, but what would happen if you had several strings we joined together? Just like SwiftUI, you would like to offer them individually and have Swift figure it out.

@resultBuilder
struct SimpleStringBuilder {
    static func buildBlock(_ parts: String...) -> String {
        parts.joined(separator: "\n")
    }
}

There is way too much to unpack in that minimal amount of code, like the @resultbuilderattribute orders Swift, where the following type ought to treat; as a result builder. 

Earlier, this result was achieved with the help of @_functionBuilder, which has an underscore to manifest that it is not designed for general use. 

Also, every result builder should provide at least one static method, i.e. buildBlock() that should take in some data to transform it. Moreover, the example mentioned above takes zero or more strings to connect them and send them back as a single string. 

In the end, the SimpleStringBuilder structure becomes a result builder, which means we can use @SimpleStringBuilder anywhere you need its joining power of string. There’s nothing that can stop us from using SimpleStringBuilder.buildBlock() like this, 

let joined = SimpleStringBuilder.buildBlock(
    "Where does the universe end",
    "How big is",
    "the universe?"
)

print(joined)

However, here we used the @resultBuilder annotation with SimpleStringBuilder struct. Thus, we can apply like this.

@SimpleStringBuilder func makeSentence3() -> String {
    "Where does the universe end",
    "How big is",
    "the universe?"
}

print(makeSentence3()

The result builder system is doing almost all the work for us. 

Moreover, it’s worth nothing that Swift 5.4 adds support for attributes on stored properties to the result builder system, which will automatically update the implicit memberwise initializer for structs to use the result builder.

This is very helpful for custom Swift UI views that uses result builders, as in: 

 

struct CustomVStack<Content: View>: View {
    @ViewBuilder let content: Content

    var body: some View {
        VStack {
            // custom functionality here
            content
        }
    }
}

#3 Revamp Implicit Member Syntax 

When defining an element inside a modifier, we do not have to specify the exact type of element. Thus, you can tie together more than one member function or property by not adding the kind at the very beginning, like this: 

.transition(.scale.move(…))

After Swift 5.4, in the end, write this code mentioned below for the same result.

#11

.transition(AnyTransistion.scale.move(…))

SE-0287 improves the ability of Swift app development to make use of implicit member expressions. Thus, rather than having support for one static member where you can make chains. 

Swift app development always carries the ability to make the use of implicit member syntax for simple expressions. 

Let’s take a perfect example; if you wish to colour some text in Swift UI, you can use .blue instead of  Color.blue:

struct ContentView1: View {
    var body: some View {
        Text("You're not my friend!")
            .foregroundColor(.blue)
    }
}

Earlier in Swift 5.4, this was not working with composite expressions. Let’s take an example. If you wish to keep the blue colour slightly transparent, you will have to  write this: 

struct ContentView2: View {
    var body: some View {
        Text("You're not my friend!")
            .foregroundColor(Color.blue.opacity(0.5))
    }

But since Swift 5.4 features came into the market, the compiler can understand multiple chained members, which means that the Color type can change according to our choice easily: 

struct ContentView3: View {
    var body: some View {
        Text("You're not my friend!")
            .foregroundColor(.blue.opacity(0.5))
    }

#4 Local Function Wrapper 

Overloading is now possible with local functions.

SR-10069 asked for the ability to overload functions in local contexts, which means nested functions can now be overloaded so Swift can choose which one to run based on the types used.

For instance, if we wanted to make some simple cookies, we could use the following code:

struct Dough { }
struct Marinara { }
struct Toppings { }

func makePizza() {
    func add(item: Dough ) {
        print("Stretch the Dough...")
    }

    func add(item: Marinara) {
        print("Adding Marinara…")
    }

    func add(item: Toppings) {
        print("Adding toppings…")
    }

    add(item: Dough())
    add(item:Marinara ())
    add(item: Toppings())
}

Before Swift 5.4, three add() methods can be overloaded only if they weren’t nested inside makePizza(), but in Swift 5.4, onward function overloading is supported in this case. 

func makePizza2() {   
    add(item: Dough())
    add(item:Marinara ())
    add(item: Toppings())


    func add(item: Dough) {
        print("Stretch the Dough...")
    }

    func add(item: Marinara) {
        print("Adding Marinara…")
    }

    func add(item: Toppings) {
        print("Adding Toppings…")
    }
}

makePizza2()

#5 Property Wrapper for Local Variable 

Property wrapper first came in Swift 5.1 to attach extra functionality to properties in an easy, reusable w. Still, in Swift 5.4, their behaviour extended to support using them as local variables in functions. 

For example, we could create a property wrapper that ensures its value never goes below zero: 

@propertyWrapper struct NonNegative<T: Numeric & Comparable> {
    var value: T

    var wrappedValue: T {
        get { value }

        set {
            if newValue < 0 {
                value = 0
            } else {
                value = newValue
            }
        }
    }

    init(wrappedValue: T) {
        if wrappedValue < 0 {
            self.value = 0
        } else {
            self.value = wrappedValue
        }
    }
}

Property wrappers were previously introduced in Swift 5.1 to quickly and reusable add new functionality to properties, but its behaviour was modified in Swift 5.4 to use as local variables in functions.

We could, for example, design a property wrapper that ensures the value of the property never falls below zero:

func playGame() {
    @NonNegative var score = 0

    // player was correct
    score += 4

    // player was correct again
    score += 8

    // player got one wrong
    score -= 15

    // player got another one wrong
    score -= 16

    print(score)
}

#6 Function Supports Same Name 

You may want to write functions with the same name on occasion. At the very least, it was something I wanted to do. We can do that with Swift 5.4.

If we build functions with the same names and have the same parameter names, our code will still operate even if the arguments have different object types.

You can try writing these down:

struct iPhone {}
struct iPad {}
struct Mac {}
func setUpAppleProducts() {
   func setUp(product: iPhone) {
       print("iPhone is bought")
   }
  
   func setUp(product: iPad) {
       print("iPad is bought")
   }
  
   func setUp(product: Mac) {
       print("Mac is bought")
   }
  
   setUp(product: iPhone())
   setUp(product: iPad())
   setUp(product: Mac())
}

In The End 

We hope that you found this article helpful. Now that WWDC 2021 week has started, people say that Swift 5.5 will be drastic and surprise every iOS app developer. 

It’s just been two days since Apple’s Worldwide Developers Conference 2021 started, and in these two days, Apple enlightened everyone with previews of iOS 15, WatchOS, MacOS Monterey, and many more. This is just the beginning of the WWDC 2021 week, and no one knows how much more is there to come in the upcoming days. 

When Swift 5.4 features dropped in the market, the whole concept of iOS app development took a 180-degree turn. Creating an iOS app is now easy, and you can also imagine the progress in iOS app development after the release of Swift 5.5. 

Also, know more about Android vs iOS to get more knowledge on what to choose in 2021. 

Suppose you have a fantastic revolutionary idea and want to bring your idea flow through the app. In that case, you can Hire iOS developers who are expert and relatively creative with their iOS App Development skills. 

Next time, we’ll be back with the new release of Swift 5.5 features. 

Till then, Ciao!