Public attributes
Public Swift language attributes are marked with the @ image, they’re (kind of) effectively documented and prepared to be used. Right here is the entire record of all the general public Swift language attributes. Most of them will appear very acquainted… 😉
@IBOutlet
Should you mark a property with the @IBOutlet attribute, the Interface Builder (IB) will acknowledge that variable and you’ll join your supply together with your visuals by means of the offered “outlet” mechanism.
@IBOutlet weak var textLabel: UILabel!@IBAction
Equally, @IBAction is an attribute that makes attainable connecting actions despatched from Interface Builder. So the marked methodology will instantly obtain the occasion fired up by the person interface. 🔥
@IBaction func buttonTouchedAction(_ sender: UIButton) {}@IBInspectable, @GKInspectable
Marking an NSCodable property with the @IBInspectable attribute will make it simply editable from the Interface Builder’s inspector panel. Utilizing @GKInspectable has the identical habits as @IBInspectable, however the property will likely be uncovered for the SpriteKit editor UI as an alternative of IB. 🎮
@IBInspectable var borderColor: UIColor = .black
@GKInspectable var mass: Float = 1.21@IBDesignable
When utilized to a UIView or NSView subclass, the @IBDesignable attribute lets Interface Builder know that it ought to show the precise view hierarchy. So principally something that you simply draw inside your view will likely be rendered into the IB canvas.
@IBDesignable class MyCustomView: UIView { }@UIApplicationMain, @NSApplicationMain
With this attribute you possibly can mark a category as the appliance’s delegate. Normally that is already there in each AppDelegate.swift file that you will ever create, nonetheless you possibly can present a fundamental.swift file and name the [UI|NS]ApplicationMain methodology by hand. #pleasedontdoit 😅
@out there
With the @out there attribute you possibly can mark varieties out there, deprecated, unavailable, and many others. for particular platforms. I am not going into the small print there are some nice posts about learn how to use the attribute with availability checkings in Swift.
@out there(swift 4.1)
@out there(iOS 11, *)
func avaialbleMethod() { }@NSCopying
You’ll be able to mark a property with this attribute to make a duplicate of it as an alternative of the worth of the property iself. Clearly this may be actually useful if you copy reference varieties.
class Instance: NSOBject {
@NSCopying var objectToCopy: NSObject
}@NSManaged
If you’re utilizing Core Knowledge entities (normally NSManagedObject subclasses), you possibly can mark saved variables or occasion strategies as @NSManaged to point that the Core Knowledge framework will dynamically present the implementation at runtime.
class Particular person: NSManagedObject {
@NSManaged var title: NSString
}@objcMembers
It is principally a comfort attribute for marking a number of attributes out there for Goal-C. It is legacy stuff for Goal-C dinosaurs, with efficiency caveats. 🦕
@objcMembers class Particular person {
var firstName: String?
var lastName: String?
}@escaping
You’ll be able to mark closure parameters as @escaping, if you wish to point out that the worth might be saved for later execution, so in different phrases the worth is allowed to survive the lifetime of the decision. 💀
var completionHandlers: [() -> Void] = []
func add(_ completionHandler: @escaping () -> Void) {
completionHandlers.append(completionHandler)
}@discardableResult
By default the compiler raises a warning when a perform returns with one thing, however that returned worth isn’t used. You’ll be able to suppress the warning by marking the return worth discardable with this Swift language attribute. ⚠️
@discardableResult func logAdd(_ a: Int, _ b: Int) -> Int {
let c = a + b
print(c)
return c
}
logAdd(1, 2)@autoclosure
This attribute can magically flip a perform with a closure parameter that has no arguments, however a return sort, right into a perform with a parameter sort of that unique closure return sort, so you possibly can name it far more simple. 🤓
func log(_ closure: @autoclosure () -> String) {
print(closure())
}
log("b") @testable
Should you mark an imported module with the @testable attribute all the interior access-level entities will likely be seen (out there) for testing functions. 👍
@testable import CoreKit
@objc
This attribute tells the compiler {that a} declaration is accessible to make use of in Goal-C code. Optionally you possibly can present a single identifier that’ll be the title of the Goal-C illustration of the unique entity. 🦖
@objc(LegacyClass)
class ExampleClass: NSObject {
@objc personal var retailer: Bool = false
@objc var enabled: Bool {
@objc(isEnabled) get {
return self.retailer
}
@objc(setEnabled:) set {
self.retailer = newValue
}
}
@objc(setLegacyEnabled:)
func set(enabled: Bool) {
self.enabled = enabled
}
}@nonobjc
Use this attribute to supress an implicit objc attribute. The @nonobjc attribute tells the compiler to make the declaration unavailable in Goal-C code, regardless that it’s attainable to signify it in Goal-C. 😎
@nonobjc static let take a look at = "take a look at"@conference
This attribute point out perform calling conventions. It could have one parameter which signifies Swift perform reference (swift), Goal-C appropriate block reference (block) or C perform reference (c).
func a(a: Int) -> Int {
return a
}
let exampleSwift: @conference(swift) (Int) -> Int = a
exampleSwift(10)Non-public attributes
Non-public Swift language attributes ought to solely be utilized by the creators of the language, or hardcore builders. They normally present further (compiler) performance that’s nonetheless work in progress, so please be very cautious… 😳
Please don’t use personal attributes in manufacturing code, except you actually know what you’re doing!!! 😅
@_exported
If you wish to import an exterior module on your complete module you need to use the @_exported key phrase earlier than your import. From now the imported module will likely be out there all over the place. Keep in mind PCH recordsdata? 🙃
@_exported import UIKit@inline
With the @inline attribute you explicitly inform the compiler the perform inlining habits. For instance if a perform is sufficiently small or it is solely getting referred to as a couple of occasions the compiler is possibly going to inline it, except you disallow it explicitly.
@inline(by no means) func a() -> Int {
return 1
}
@inline(__always) func b() -> Int {
return 2
}
@_inlineable public func c() {
print("c")
}
c()@inlinable is the long run (@_inlineable) by Marcin Krzyzanowskim 👏
@results
The @results attribute describes how a perform impacts “the state of the world”. Extra virtually how the optimizer can modify this system primarily based on info that’s offered by the attribute. You could find the corresponding docs right here.
@results(readonly) func foo() { }@_transparent
Mainly you possibly can pressure inlining with the @_transparent attribute, however please learn the unofficial documentation for more information.
@_transparent
func instance() {
print("instance")
}@_specialize
With the @_specialize Swift attribute you may give hints for the compiler by itemizing concrete varieties for the generic signature. Extra detailed docs are right here.
struct S<T> {
var x: T
@_specialize(the place T == Int, U == Float)
mutating func exchangeSecond<U>(_ u: U, _ t: T) -> (U, T) {
x = t
return (u, x)
}
}
@_semantics
The Swift optimizer can detect code in the usual library whether it is marked with particular attributes @_semantics, that identifies the features. You’ll be able to examine semantics right here and right here, or inside this concurrency proposal.
@_semantics("array.rely")
func getCount() -> Int {
return _buffer.rely
}@silgenname
This attribute specifies the title {that a} declaration may have at hyperlink time. You’ll be able to examine it contained in the Customary Librery Programmers Handbook.
@_silgen_name("_destroyTLS")
inner func _destroyTLS(_ ptr: UnsafeMutableRawPointer?) {
}@_cdecl
Swift compiler comes with a built-in libFuzzer integration, which you need to use with the assistance of the @_cdecl annotation. You’ll be able to study extra about libFuzzer right here.
@_cdecl("LLVMFuzzerTestOneInput")
public func fuzzMe(Knowledge: UnsafePointer<CChar>, Dimension: CInt) -> CInt{
}
}Unavailable, undocumented, unknown
As you possibly can see that is already fairly a listing, however there’s much more. Contained in the official Swift repository you will discover the attr exams. Should you want extra information concerning the remaining Swift annotations you possibly can go instantly there and examine the supply code feedback. Should you might assist me writing concerning the leftovers, please drop me a couple of traces, I might actually admire any assist. 😉👍
- @requiresstoredproperty_inits
- @warnunqualifiedaccess
- @fixedlayout
- @_versioned
- @showin_interface
- @_alignment
- @objcnonlazy_realization
- @_frozen
- @_optimize(none|velocity|measurement)
- @_weakLinked
- @consuming
- @_restatedObjCConformance
- @_staticInitializeObjCMetadata
- @setterAccess
- @rawdoccomment
- @objc_bridged
- @noescape -> eliminated, see @escaping
- @noreturn -> eliminated, see By no means sort
- @downgradeexhaustivity_check -> no impact on swap case anymore?
- @_implements(…) – @implements(Equatable, ==(:_:))
- @swiftnativeobjcruntime_base(class)
The @_implements attribute, which treats a decl because the implementation for some named protocol requirement (however in any other case not-visible by that title).
This attribute signifies a category that must be handled semantically as a local Swift root class, however which inherits a particular Goal-C class at runtime. For many lessons that is the runtime’s “SwiftObject” root class. The compiler doesn’t must know concerning the class; it is the construct system’s accountability to hyperlink towards the ObjC code that implements the basis class, and the ObjC implementation’s accountability to make sure cases start with a Swift-refcounting-compatible object header and override all the mandatory NSObject refcounting strategies.
This permits us to subclass an Goal-C class and use the quick Swift reminiscence allocator. If you wish to add some notes about these attributes, please contact me.