Swift offers several techniques to optimize your code:

Use let instead of var: When you know that a variable won’t change, declare it as a constant using let. This allows the Swift compiler to make optimizations. More details here

Lazy Initialization: Use lazy keyword for expensive computations. The value gets computed only when it is accessed for the first time.

Avoid Using High-Level Functions Unnecessarily: High-level functions like map, filter, reduce are very convenient, but they can be slower than simple for loops.

Inlining Functions: Small functions can be inlined using the @inline(__always) attribute. This can potentially improve performance by eliminating the overhead of a function call.

@inline(__always) func add(_ a: Int, _ b: Int) -> Int {
    return a + b
}

Use Enumerated Types for Control Flow: Instead of using strings or integers for control flow, use Swift’s enumerated types (enum). This can make your code safer and more efficient.

Avoid Using Optional Chaining Unnecessarily: Optional chaining (?.) can be slower than forced unwrapping (!). If you’re sure that an optional won’t be nil, consider using forced unwrapping.

Use Final Classes: If you know that a class won’t be subclassed, declare it as final. This allows the Swift compiler to make optimizations.

In Swift, the final keyword is used to indicate that a class cannot be subclassed, a method cannot be overridden, or a property cannot be overridden. This has several benefits for performance:

1. Method Dispatch: In Swift, methods in a class can be called through dynamic dispatch or static dispatch. Dynamic dispatch is a bit slower because it requires looking up the method implementation at runtime. When you mark a class as final, Swift can use static dispatch for its methods because it knows they can’t be overridden by a subclass. This can make method calls faster.
2. Inlining: Similar to the above point, when a method is known to not be overridden (because it’s in a final class), the compiler can sometimes inline the method. Inlining is a performance optimization where the compiler replaces a method call with the method’s body, eliminating the overhead of the method call.
3. Memory Layout: Knowing that a class is final can allow the compiler to make optimizations to the memory layout of the class and its instances. For example, it might be able to place instances of the class more efficiently in memory, or it might be able to simplify the class’s vtable (a data structure used in dynamic dispatch).

Avoid Dynamic Dispatch: Use private or final to avoid dynamic dispatch where possible. Dynamic dispatch can be slower than static dispatch.

Use Generics Wisely: Generics can make your code more flexible and reusable, but they can also slow down your code. If performance is a concern, consider using concrete types instead.

Use Swift’s Built-In Collections: Swift’s built-in collections like Array, Dictionary, and Set are highly optimized. Use them instead of creating your own data structures.

Remember, always measure before and after applying these techniques to ensure they’re actually improving your code’s performance. Use Xcode’s Instruments tool to profile your app and find bottlenecks.