Swift Miscellany: Keywords, Reserved And Escaped

There are a fair few keywords in Swift 2.0, I think we’re up to around about seventy-five at the moment, but it wasn’t until I started rummaging around in the grammar that I discovered that some of them are context senstive.

The context sensitive keywords are those which are used in only one specific context and most of the declaration modifiers

Infix Operator Declaration

• associativity

• left

• none

• precedence

• right

are reserved keywords in the context of an infix-operator-declaration.

    infix-operator-declaration → infix operator operator { infix-operator-attributesopt }

    infix-operator-attributes  → precedence-clauseopt associativity-clauseopt

    precedence-clause          → precedence precedence-level

    associativity-clause       → associativity associativity

    associativity              → left | right | none

Computed Properties/Variables

• get

and

• set

are reserved keywords in the context of a computed property/variable declaration.

    variable-declaration → variable-declaration-head variable-name type-annotation getter-setter-block

    getter-setter-block  → { getter-clause setter-clauseopt }

    getter-setter-block  → { setter-clause getter-clause }

    getter-clause        → attributesopt get code-block

    setter-clause        → attributesopt set setter-nameopt code-block

Property/Variable Observers

• didSet

and

• willSet

are keywords in the context of a stored variable observer declaration or a property observer declaration

    variable-declaration  → variable-declaration-head variable-name initializer willSet-didSet-block

    variable-declaration  → variable-declaration-head variable-name type-annotation initializeropt willSet-didSet-block

    willSet-didSet-block  → { willSet-clause didSet-clauseopt }

    willSet-didSet-block  → { didSet-clause willSet-clauseopt }

    willSet-clause        → attributesopt willSet setter-nameopt code-block

    didSet-clause         → attributesopt didSet setter-nameopt code-block

Metatype Type

• Protocol

and

• Type

are keywords in the context of a metatype-type

    metatype-type → type  . Type | type  . Protocol 

Declaration Modifiers

• convenience

• dynamic

• final

• infix

• indirect

• lazy

• mutating

• nonmutating

• optional

• override

• postfix

• prefix

• required

• unowned

• weak

are reserved keywords when they appear before a declaration.

When not being used in their specific contexts reserved keywords can moonlight as identifiers which means that you can, if you want to, do this

    ...
    
    private var final    = true
    private var left     = true
    private var optional = true
    private var override = false
    private var required = true
    private var right    = false
    private var set      = true
    private var unowned  = true
    private var weak     = false
    
    ...

or this

    enum associativity
    {
        case left
        case right
        case none
    }

or even this

    func infix()
    {
    
    }

Escaped Keywords

If your favourite identifier is a non-reserved Swift keyword there is still hope.

Any Swift keyword can be used as an identifier if it is escaped, so if you have always wanted a class called class

    class `class`
    {
    
    }

or a global variable called self

    var `self` = `class`()

you can have one.

The escape character is the grave accent/backtick/backquote character (`) ASCII 96/0x60.

---

Copyright (c) 2015 By Simon Lewis. All Rights Reserved.

Unauthorized use and/or duplication of this material without express and written permission from this blog’s author and owner Simon Lewis is strictly prohibited.

Excerpts and links may be used, provided that full and clear credit is given to Simon Lewis and justanapplication.wordpress.com with appropriate and specific direction to the original content.