Скачать или смотреть Why Does My Framework Expose Pure Swift enum as a non-closed enum? Find the Solution with @ frozen

Discover how to handle pure Swift enums in your framework to avoid warnings about `@ unknown default` by using the `@ frozen` keyword.
---
This video is based on the question https://stackoverflow.com/q/75080603/ asked by the user 'Isaaс Weisberg' ( https://stackoverflow.com/u/9353387/ ) and on the answer https://stackoverflow.com/a/75080910/ provided by the user 'Isaaс Weisberg' ( https://stackoverflow.com/u/9353387/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Why does my Framework expose pure Swift `enum` as a `non-closed enum`, requiring usage of `@ unknown default`?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding the Issue of Non-Closed Enums in Swift Frameworks

When developing applications with Swift, you may encounter situations that seem perplexing, particularly when building frameworks. One such issue is when a framework exposes a pure Swift enum as a non-closed enum, requiring the use of @ unknown default in switch statements. This might raise a few eyebrows, especially since Swift enums are designed to be type-safe and predictable.

The Problem: Non-Closed Enum Warning

Imagine you have a dynamic framework that uses some Objective-C code, and you’re managing this compilation through Xcode, employing a bridging header. You define a simple public enum like this:

[[See Video to Reveal this Text or Code Snippet]]

This might look straightforward and well-defined, but upon compiling your framework and importing it, you receive a surprising warning similar to this:

[[See Video to Reveal this Text or Code Snippet]]

This warning suggests that while you have defined cases, Swift assumes there could be additional cases introduced at runtime, which leads to the requirement of handling unknown values.

Why Does This Happen?

Upon inspecting the .swiftinterface file of your framework, you may find that everything seems properly declared:

[[See Video to Reveal this Text or Code Snippet]]

The apparent contradiction lies in how Swift handles enums in a dynamically linked framework. Swift assumes that because the framework could be updated separately from your app, additional enum cases may exist in a future version. This leads to the warning designating Foo as a non-closed enum.

The Solution: Using the @ frozen Keyword

What is @ frozen?

The solution to this issue is to mark your enum with the @ frozen attribute. This tells Swift that the enum, once published, will not receive any new cases, making it safe to omit the @ unknown default clause when using switch statements.

How to Implement @ frozen

Updating your enum to utilize the @ frozen keyword is simple. Here’s how you should modify your existing enum:

[[See Video to Reveal this Text or Code Snippet]]

Benefits of @ frozen

By declaring an enum as @ frozen:

Eliminates the need for @ unknown default: You can use switch statements without worrying about unknown cases.

Ensures consistency: You provide clear information to Swift's compiler, reinforcing that your enum's cases are stable and won't change across versions.

Improves code maintenance: Reduces the clutter in your switch statements, making them cleaner and easier to read.

Conclusion

In summary, the warning regarding @ unknown default is a common hurdle when dealing with enums in Swift frameworks, especially when Objective-C interoperability is involved. By marking your enum with @ frozen, you can confidently use it without the need for additional handling of unknown cases. Such clarity bolsters your code's safety and maintainability, allowing for cleaner implementations moving forward.

Now, with a clear understanding of this problem and its solution, you're well-equipped to handle enums in your Swift frameworks better. Happy coding!