Enforcing struct type

Using Swift
1

Is there a known best idiom for enforcing that a generic type is a struct type and not a class? We have AnyObject for enforcing a class but I don't think there is anything like this for structs, is there?

The usecase is a package that needs a State type that can be observed (via @Observable). Internally, the package wraps the generic type provided by the package user in an @Observable class but observation won't work unless the State property is a struct, right?

I can put together something Mirror-based or a macro perhaps that the package code uses to fail compilation. Is there anything else that is simpler/more elegant/builtin-ish that I may be missing?

2

A struct constraint wouldn't help in this scenario as a struct can just wrap a mutable class and you will have the same problem again. The obvious next idea of making it a recursive requirement of all store properties is too strict because it is possible to implement a struct that wraps a class in a way that @Observable can observe changes. All container types like String, Array, Set, Dictionary etc. do exactly that.

What you probably want is something that is often referred to as a "value semantics" constraint or "value types" although I don't think we ever landed on a formal definition of the term. Generally the idea of such a constraint would be that all mutations need to go through a mutating access (which is what @Observable picks up through the set/_modify accessor) and otherwise the value can't change.

Edit: For @Observable this would actually be too restrictive as well as other classes that also use @Observable are actually fine and work with the observation system.

2 Likes
3

May I interest you in _isPOD function?

struct T1 {}
enum T2 {}
class T3 {}
actor T4 {}

struct ST1 {
    var foo: T3
}

enum ST2 {
    case foo(T3)
}

print(_isPOD(T1.self)) // true
print(_isPOD(T2.self)) // true
print(_isPOD(T3.self)) // false
print(_isPOD(T4.self)) // false

print(_isPOD(ST1.self)) // false
print(_isPOD(ST2.self)) // false
4

_isPOD and the BitwiseCopyable protocol are options but IMO probably too restrictive as well to be really useful for restricting what can be used in @State/@Observable. If you can't use String, Array or any other dynamically sized data structure in your model you will not get very far.

5 Likes
5

I don't know of a way to enforce it at compile time, but you could add a deprecation warning with overloads:

@available(
  *,
  deprecated,
  message: "Cannot initialize with non-Observable object"
)
init(_ state: State) where State: AnyObject { ā€¦ }

init(_ state: State) where State: AnyObject & Observable { ā€¦ }

Or you could check if the type is an AnyObject.Type for a runtime warning.

You could also check the runtime metadata if you really specifically care about it being a struct (as opposed to an enum or a tuple):

func isStruct(_ type: Any.Type) -> Bool {
  unsafeBitCast(type, to: UnsafeRawPointer.self).load(as: UInt.self)
    == 0x200
}

Of course all of these checks are only good for the root State type, and nested, non-observable classes will still stop observation.

So probably the big question is what your ultimate goal is. It's possible that documenting things is enough.

1 Like
6

There's a formal definition of value semantics in this paper.

4 Likes
7

I just wanted to ensure that there are no surprises and observation works for the State provided by the client of the package. As you said, documenting the requirement may just be enough.

Thanks for all the suggestions and info.