A Swift Introduction

A Swift Introduction.swift

// Playground - noun: a place where people can play

import Cocoa

// Variable names in Emoji!
var 💩 = "poo"
let 🐶 = "dog"

// A simple function.
let myName = "Jeff"

func reverseString(string: String) -> String {
    var output = ""
    
    for character in string {
        output = String(character) + output
    }
    
    return output
}

reverseString(myName)


// Evolving a function to use named parameters and default values.
/*
func printEmojiForAnimals(🐶: Character, 🐱: Character, 🐴: Character, 🐮: Character) {
    println("Dog: \(🐶)")
    println("Cat: \(🐱)")
    println("Horse: \(🐴)")
    println("Cow: \(🐮)")
}

printEmojiForAnimals("🐶", "🐱", "🐴", "🐮")
*/

/*
func printEmojiForAnimals(dog 🐶: Character, cat 🐱: Character, horse 🐴: Character, cow 🐮: Character) {
    println("Dog: \(🐶)")
    println("Cat: \(🐱)")
    println("Horse: \(🐴)")
    println("Cow: \(🐮)")
}

printEmojiForAnimals(dog: "🐶", cat: "🐱", horse: "🐴", cow: "🐮")
*/

/*
func printEmojiForAnimals(dog 🐶: Character = "🐶", cat 🐱: Character = "🐱", horse 🐴: Character = "🐴", cow 🐮: Character = "🐮") {
    println("Dog: \(🐶)")
    println("Cat: \(🐱)")
    println("Horse: \(🐴)")
    println("Cow: \(🐮)")
    
}

printEmojiForAnimals(dog: "🐶", cat: "🐱", horse: "🐴", cow: "🐮")
*/

/*
func printEmojiForAnimals(dog 🐶: Character = "🐶", cat 🐱: Character = "🐱", horse 🐴: Character = "🐴", cow 🐮: Character = "🐮") {
    println("Dog: \(🐶)")
    println("Cat: \(🐱)")
    println("Horse: \(🐴)")
    println("Cow: \(🐮)")
    
}

printEmojiForAnimals()
*/

func printEmojiForAnimals(dog 🐶: Character = "🐶", cat 🐱: Character = "🐱", horse 🐴: Character = "🐴", cow 🐮: Character = "🐮") {
    println("Dog: \(🐶)")
    println("Cat: \(🐱)")
    println("Horse: \(🐴)")
    println("Cow: \(🐮)")
}

printEmojiForAnimals(cat: "🐯")


// Functions can return tuples.
func bounds(integers: [Int]) -> (min: Int, max: Int) {
    var min = Int.max
    var max = Int.min
    
    for n in integers {
        if (n < min) { min = n }
        if (n > max) { max = n }
    }
    
    return (min, max)
}

var result = bounds([1,2,3,4])

var min = result.min	// 1
var max = result.max	// 4


// Optionals
func logWithOptionalString(string: String? = nil) {
    if let message = string {
        NSLog("Received message %@", message)
    }
    else {
        NSLog("Logged with no message")
    }
}

logWithOptionalString(string: "Hello")
logWithOptionalString()


// Inheritance
class Animal {
    var color: NSColor
    let name: String
    
    init (color: NSColor, name: String) {
        self.color = color
        self.name = name
    }
}

class Dog : Animal {
    var chasesCars: Bool = true
    
    init(color: NSColor, name: String, chasesCars: Bool) {
        self.chasesCars = chasesCars
        super.init(color: color, name: name)
    }
    
    func bark() {
        println("Woof!")
    }
}

var Bella = Dog(color: NSColor.whiteColor(), name: "Bella", chasesCars: false)

class Chihuahua : Dog {
    override func bark() {
        println("Yip yip yip yip!")
    }
}

typealias Doge = Dog

class Shibe : Doge {
    init(name: String) {
        super.init(color: NSColor.orangeColor(), name: name, chasesCars: false)
    }
    
    override func bark() {
        println("wow")
    }
}

var superShibe = Shibe(name: "much subclass")

class 🐱 : Animal {
    let cares = false
}

let kitty = 🐱(color: NSColor.whiteColor(), name: "Kitty Cat");

kitty.color = NSColor.blueColor()

extension Dog {
    func walkInACircle() {
        
    }
    
    func lieDown() {
        
    }
}

extension Dog {
    func goToBed() {
        walkInACircle()
        walkInACircle()
        walkInACircle()
        walkInACircle()
        
        lieDown()
    }
}

extension NSView {
    func makeKindaTransparent() {
        self.alphaValue = 0.5
    }
}

extension CGRect {
    func area() -> CGFloat {
        return CGRectGetWidth(self) * CGRectGetHeight(self)
    }
}

var rect = CGRect(x: 100, y: 100, width: 512, height: 512)
rect.area()	// 262144.0

class Star {
    let name: String = ""
    
    init(name: String) {
        self.name = name
    }
}

class Planet {
    let name: String = ""
    let gravity: Double
    
    init(name: String, gravity: Double) {
        self.name = name
        self.gravity = gravity
    }
}

var sol = Star(name: "Sol")
var mercury = Planet(name: "Mercury", gravity: 0.38)
var venus = Planet(name: "Venus", gravity: 0.9)
var earth = Planet(name: "Earth", gravity: 1)
var mars = Planet(name: "Mars", gravity: 0.38)
var jupiter = Planet(name: "Jupiter", gravity: 2.64)
var saturn = Planet(name: "Saturn", gravity: 1.16)
var uranus = Planet(name: "Uranus", gravity: 1.11)
var neptune = Planet(name: "Neptune", gravity: 1.21)
var pluto = Planet(name: "Pluto", gravity: 1/12)

struct SolarSystem {
    let star: Star
    var planets: [Planet]?
}

extension SolarSystem {
    func description() -> String {
        var description = "The \(star.name) system"
        
        if let planets = planets {
            description += ", orbited by "
            
            for i in 0 ..< planets.count {
                description += planets[i].name
                
                if (i + 2 == planets.count) {
                    description += ", and "
                }
                else if (i + 1 < planets.count) {
                    description += ", "
                }
            }
        }
        
        return description
    }
}

var ourSystem = SolarSystem(star: sol, planets: [mercury, venus, earth, mars, jupiter, saturn, uranus, neptune])
ourSystem.description()	// The Sol system, orbited by Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, and Neptune

if (ourSystem.planets != nil) {
    ourSystem.planets!.append(pluto)
}

ourSystem.planets!.count	// 9

/* Uncomment to switch back to struct-based Articles, just comment out the class below.
struct Article {
    var title: String
    var byline: String
    var content: String
    
    mutating func fixTitle() -> () {
        self.title = self.title.capitalizedString
    }
}
*/

enum ArticleType {
    case Opinion
    case LongForm
    case PoliticalCartoon([NSImage])
    case Editorial
    case LetterToTheEditor
    case PoemByEECummings
}

class Article {
    var title: String
    var byline: String
    var content: String
    let type: ArticleType
    
    init(title: String, byline: String, content: String, type: ArticleType) {
        self.title = title
        self.byline = byline
        self.content = content
        self.type = type
    }
}

extension Article {
    func fixTitle() -> () {
        switch type {
        case .PoliticalCartoon(let images):
            self.title = self.title.capitalizedString + " (\(images.count) panels)"
        case .PoemByEECummings:
            self.title = self.title.lowercaseString
        default:
            self.title = self.title.capitalizedString
        }
    }
}

class ArticlePreparer {
    var article: Article
    
    init(article: Article) {
        self.article = article
    }
    
    func prepareForSubmission() -> () {
        article.fixTitle()
    }
}

var swiftIsAwesome = Article(title: "Swift is awesome", byline: "by Jeff Kelley", content: "💩 is a valid class name.", type:.Opinion)

var preparer = ArticlePreparer(article: swiftIsAwesome)
preparer.prepareForSubmission()

swiftIsAwesome.title	// "Swift Is Awesome"

func mySwap<T>(inout a: T, inout b: T) {
    var c = b
    b = a
    a = c
}

var a = 42
var b = 9_001

mySwap(&a, &b)

a	// 9001
b	// 42


// Evolving a way to sort planets by gravity.
/*
func sortByGravity(p1: Planet, p2: Planet) -> Bool {
    return p1.gravity > p2.gravity
}

var sortedPlanets = ourSystem.planets!.sorted(sortByGravity)
*/

/*
var sortedPlanets: [Planet] =
ourSystem.planets!.sorted({
    (p1: Planet, p2: Planet) -> Bool in
    return p1.gravity > p2.gravity
})
*/

/*
var sortedPlanets: [Planet] =
ourSystem.planets!.sorted {
    (p1: Planet, p2: Planet) -> Bool in
    return p1.gravity > p2.gravity
}
*/

/*
var sortedPlanets =
ourSystem.planets!.sorted {
    (p1: Planet, p2: Planet) -> Bool in
    return p1.gravity > p2.gravity
}
*/

/*
var sortedPlanets =
ourSystem.planets!.sorted {
    (p1, p2) -> Bool in
    return p1.gravity > p2.gravity
}
*/

/*
var sortedPlanets =
ourSystem.planets!.sorted {
    p1, p2 in
    return p1.gravity > p2.gravity
}
*/

/*
var sortedPlanets =
ourSystem.planets!.sorted {
    p1, p2 in
    p1.gravity > p2.gravity
}
*/

/*
var sortedPlanets = ourSystem.planets!.sorted { $0.gravity > $1.gravity }
*/


// Now with using operator overloading.
func > (left: Planet, right: Planet) -> Bool {
    return left.gravity < right.gravity
}

/*
var sortedPlanets = ourSystem.planets!.sorted { $0 > $1 }
*/

var sortedPlanets = ourSystem.planets!.sorted(>)