“SwiftData inheritance relationship”

Another way to explain why I'd like to be able to use my type(s) with for-in without getting all stuff from SequenceType et al might be by this example:TL;DR:My StaticArrayType(s) has type-level Count, thus SequenceType == bad fit, OK, fine, makes sense. But I'd still like to:for e in myStaticArray { … }I could have, if only the stdlib had a simpler protocol whose only requirement was that conforming types had a generate() method.I have a protocol called StaticArrayType which describes a set of common requirements for concrete (value) types that have/are a statically allocated fixed number of elements (of type Element). So the memory layout of any static array type is fixed and both its element type and its count are encoded at the type level by associated types Element: DefaultInitializable andCount: CountType.The Count type can be used to type check the number of elements and the Element type can be used to type check the element type.(The memory layout of any static array type is fixed and known since eg a

I ran into the same problem, with the same solution, in using an NSObject derived class and binding an Array Controller to a Table View.So question, when do we need to add @objc(ClassName) for an NSObject derived class ?I read in « Using Swift with Cocoa and Objective-C. » that« When you define a Swift class that inherits from NSObject or any other Objective-C class, the class is automatically compatible with Objective-C. All of the steps in this section have already been done for you by the Swift compiler. »It also says:« The @objc attribute makes your Swift API available in Objective-C and the Objective-C runtime. »Is binding calling Objective C runtime in the background (My code is pure Swift) ?

It is type save to return a derrived type, co-varient return tpe overloads are common in many type-safe languages. In this case all BarModels are BarViewModels, therefore you can always (1) put a BarModel where a BarViewModel is expected. You can see this in the class version that allows, and works as expected, getBar() -> BarModel to override getBar() -> BarViewModel.However even though it is type safe to have co-varient return types the language could just simply ban this, early versions of Java did for example. Therefore the reason I think it is a bug is because co-varient return types are allowed in classes and you should be able to change a class into a protocol (provided that there is no functionality used in the class that cannot be expressed as a protocol). In this specific case you can declare a method in both a class and a protocol and therefore I would expect the same declarion in a different context, class or protocol, to have the same meaning.(1) The statement you can always put a BarModel

This doesn't compile:class C { var someProperty: Self {return self} }and it's pointless for either to compile:protocol CType {} extension CType { func someMethod() -> Self {return self} var someProperty: Self {return self} }Reference types being tied in with inheritance is a weird overload.

This is (at least the beginning of) a great example of why I'm staying away from classes, not to mention inheritance, as much as I possibly can in my code, and in (the topic of) this thread. : )

Inheritance is ridiculous and I expect that it will be deprecated in Swift for non-objc types.protocol ThingType {} extension ThingType { static var name: String {return ThingType} } class Thing: ThingType { static var defaultName: String {return (Thing.self as ThingType.Type).name} static var name = Thing }

As the title says: structs (not classes) ... so I repeat:This is (at least the beginning of) a great example of why I'm staying away from classes, not to mention inheritance, as much as I possibly can in my code, and in (the topic of) this thread. : )

I think bob133 gave you the correct answer accidentally. 'Self' as the return type in a class is exactly what 'instancetype' is in Obj-C. It means a class determined by the call site, which may be a subclass of the class of the declaration site of the method. In fact, using the class name instead is semantically different from Self.In structs, without any inheritance, the only possibility is the struct containing the declaration, so you can use the literal name of the type. OTOH, allowing 'Self' would seem to be harmless.As far as protocols are concerned (and classes using Self conforming to protocols using Self), I was not able to find documentation on what it means, the last time I looked.

I believe that means the (stored) properties have to be defined in the class that adopted the protocol. I have to say that I am confused by protocol extensions. The extension is to the protocol. Is that effectively the same as the class having that extension, and that the etension methods can be called from an object of that class? Then the protocol itself says what must be defined in the class for calls from the extension methods. Do I have that right?One issue is that if i had multiple inheritance, I could define methods which need to be overriden in the new class. But that is not possible with protocols and extensions.