gameLoop: while square != finalSquare {
    if ++diceRoll == 7 { diceRoll = 1 }
    switch square + diceRoll {
    case finalSquare:
        // diceRoll will move us to the final square, so the game is over
        break gameLoop
    case let newSquare where newSquare > finalSquare:
        // diceRoll will move us beyond the final square, so roll again
        continue gameLoop
    default:
        // this is a valid move, so find out its effect
        square += diceRoll
        square += board[square]

func sayHello(personName: String) -> String {
    let greeting = "Hello, " + personName + "!"
    return greeting
}

func count(string: String) -> (vowels: Int, consonants: Int, others: Int) {
    var vowels = 0, consonants = 0, others = 0
    for character in string {
        switch String(character).lowercaseString {
        case "a", "e", "i", "o", "u":
            ++vowels
        case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
        "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
            ++consonants
        default:
            ++others
        }
    }
    return (vowels, consonants, others)

let total = count("some arbitrary string!")
println("\(total.vowels) vowels and \(total.consonants) consonants")

func addTwoInts(a: Int, b: Int) -> Int {
    return a + b
}

int (^addTwoInts)(int, int) = ^(int a, int b) {
    return a + b;
}

enum Barcode {
    case UPCA(Int, Int, Int)
    case QRCode(String)
}

From the documentation section labeled Classes and Structures:

NOTE

An instance of a class is traditionally known as an object. However, Swift classes and structures are much closer in functionality than in other languages, and much of this chapter describes functionality that can apply to instances of either a class or a structure type. Because of this, the more general term instance is used.

Inheritance enables one class to inherit the characteristics of another.
Type casting enables you to check and interpret the type of a class instance at runtime.
Deinitializers enable an instance of a class to free up any resources it has assigned.
Reference counting allows more than one reference to a class instance.

If you have experience with C, C++, or Objective-C, you may know that these languages use pointers to refer to addresses in memory. A Swift constant or variable that refers to an instance of some reference type is similar to a pointer in C, but is not a direct pointer to an address in memory, and does not require you to write an asterisk (*) to indicate that you are creating a reference. Instead, these references are defined like any other constant or variable in Swift.

extension Int {
    func repetitions(task: () -> ()) {
        for i in 0..self {
            task()
        }
    }
}

3.repetitions {
    println("Goodbye!")
}
// Goodbye!
// Goodbye!
// Goodbye!

extension Int {
    mutating func square() {
        self = self * self
    }
}
var someInt = 3
someInt.square()
// someInt is now 9

        static void Main(string[] args)
        {
            var cake = new BakeBase();
            var cherryCake = new CherryCake(cake);
            var creamCherryCake = new CreamCake(cherryCake);

            Console.WriteLine(Environment.NewLine);

            Console.WriteLine(cake.PriceDetails);

            Console.WriteLine(Environment.NewLine);

            Console.WriteLine(cherryCake.PriceDetails);

            Console.WriteLine(Environment.NewLine);

            Console.WriteLine(creamCherryCake.PriceDetails);

let x = 1
let y = x &/ 0
// y is equal to 0