Usually when I learn a new language I tend to jump straight into the “Hello World” example and get my hands wet immediately. Because I have already used the first iteration of Swift and more recently in a project I used Swift 2, I’m going to do this deep dive into the language a little bit differently.

Rather than starting with examples, I’m going to start with the language grammar. Traditionally this is not how people are taught a language, but I find that looking at the grammar of a language gives you a much better understanding of how the language works.

I’m going to work from the grammar as it is defined in the language reference. See, “About the Language Reference” under the title “How to Read the Grammar” for an explanation of the syntax.

First things first, the grammar is made up of tokens. A token consists of the following: An identifier, a keyword, punctuation, a literal or an operator. This can seem very confusing if you have never looked at syntax before, so lets break down a simple statement.

var number = 2

This is a valid token in Swift. var is a keyword, number is our identifier, = is an assignment operator and 2 is a numerical decimal literal. We know that this token is valid because the Swift grammar tells us that it is. In this case the grammar is:

statement → declaration ;_optional

declaration → variable-declaration

variable-declaration → variable-declaration-head pattern-initializer-list

variable-declaration-head → attributes_optional declaration-modifiers_optional var

pattern-initializer-list → pattern-initializer | pattern-initializer, pattern-initializer-list

pattern-initializer → pattern initializer_optional

pattern → identifier-pattern type-annotation_optional

identifier-pattern → identifier

identifier → identifier-head identifier-characters_optional

identifier-head → Upper- or lowercase letter A through Z

identifier-characters → identifier-character identifier-characters_optional

identifier-character → identifier-head

initializer → = expression

expression → try-operator_optional prefix-expression binary-expressions_optional

prefix-expression → prefix-operator_optional postfix-expression

postfix-expression → primary-expression

primary-expression → literal-expression

literal-expression → literal

literal → numeric-literal | string-literal | boolean-literal | nil-literal

numeric-literal → –_optional integer-literal | –_optional floating-point-literal

integer-literal → decimal-literal

decimal-literal → decimal-digit decimal-literal-characters_optional

decimal-digit → Digit 0 through 9

That is an amazing amount of steps that Swift need to evaluate to determine whether such a simple variable declaration is valid grammar or not. As I was going through the grammar I chose the shortest possible path and I’m glad I only chose one digit. I did not even touch on the full grammar for each of the tokens.

As you are learning Swift I’d encourage you to take a look at the grammar of even your simplest statements to get a more in depth understanding of the language.

I personally find this fascinating to go through code like this, but I’m sure that this post is not for everyone. Hang in there, we’ll get to code soon, but from time to time I might refer back to the grammar.

Enjoy digging into the grammar of Swift.