From the Swift blog:
This feature was first released in Xcode 6.3 with the keywords
__nonnull. Due to potential conflicts with third-party libraries, we’ve changed them in Xcode 7 to the
_Nonnullyou see here. However, for compatibility with Xcode 6.3 we’ve predefined macros
__nonnullto expand to the new names.
The nullability (type) qualifiers express whether a value of a given pointer type can be null (the
_Nullablequalifier), doesn’t have a defined meaning for null (the
_Nonnullqualifier), or for which the purpose of null is unclear (the
_Null_unspecifiedqualifier). Because nullability qualifiers are expressed within the type system, they are more general than the
returns_nonnullattributes, allowing one to express (for example) a nullable pointer to an array of nonnull pointers. Nullability qualifiers are written to the right of the pointer to which they apply.
In Objective-C, there is an alternate spelling for the nullability qualifiers that can be used in Objective-C methods and properties using context-sensitive, non-underscored keywords
So for method returns and parameters you can use the
the double-underscored versions
__null_unspecified instead of either the single-underscored ones, or instead of the non-underscored ones. The difference is that the single and double underscored ones need to be placed after the type definition, while the non-underscored ones need to be placed before the type definition.
Thus, the following declarations are equivalent and are correct:
- (nullable NSNumber *)result - (NSNumber * __nullable)result - (NSNumber * _Nullable)result
- (void)doSomethingWithString:(nullable NSString *)str - (void)doSomethingWithString:(NSString * _Nullable)str - (void)doSomethingWithString:(NSString * __nullable)str
@property(nullable) NSNumber *status @property NSNumber *__nullable status @property NSNumber * _Nullable status
Things however complicate when double pointers or blocks returning something different than void are involved, as the non-underscore ones are not allowed here:
- (void)compute:(NSError * _Nullable * _Nullable)error - (void)compute:(NSError * __nullable * _Null_unspecified)error; // and all other combinations
Similar with methods that accept blocks as parameters, please note that the
nullable qualifier applies to the block, and not its return type, thus the following are equivalent:
- (void)executeWithCompletion:(nullable void (^)())handler - (void)executeWithCompletion:(void (^ _Nullable)())handler - (void)executeWithCompletion:(void (^ __nullable)())handler
If the block has a return value, then you're forced into one of the underscore versions:
- (void)convertObject:(nullable id __nonnull (^)(nullable id obj))handler - (void)convertObject:(id __nonnull (^ _Nullable)())handler - (void)convertObject:(id _Nonnull (^ __nullable)())handler // the method accepts a nullable block that returns a nonnull value // there are some more combinations here, you get the idea
As conclusion, you can use either ones, as long as the compiler can determine the item to assign the qualifier to.