Swift2-code-snippets.swift

func  compareGreaterThan(a:Int, b:Int) -> Bool{
    return a > b
}

func compareLessThan(a:Int, b:Int) -> Bool{
    return a < b
}

func comparator(greaterThan:Bool) -> (Int, Int) -> Bool {
    if greaterThan {
        return compareGreaterThan
    }
    
    return compareLessThan
}

print(comparator(true)(1,2))

enum MobileDevice : String
{
    case iPhone = "iPhone", Android = "Android", WP8 = "Windows Phone8", BB = "BlackBerry"
    
    func name() -> String
    {
        return self.rawValue + " " + self.rawValue
    }
}
let m = MobileDevice.Android
print(m.name())    // "Android"

enum Test {
    case Address(streetName:String, postcode:String)
    case LatLong(lat:Int, long:Int)
    func description() -> String{
        switch self{
        case let .Address(streetName, postcode):
            return streetName + " ," + postcode
        case let .LatLong(lat, long):
            return "\(lat) , \(long)"
        }
    }
}

let mm = Test.Address(streetName: "my street", postcode: "N36G5")
let mmm = Test.LatLong(lat: 234, long: 94)

print(mm.description())
print(mmm.description())

func intDivision(a:Int, b:Int) -> (quotient:Int, remainder:Int) {
    return (a/b, a%b)
}
let a = intDivision(30, b: 4)
print(a.remainder)

let complex = (2.0, 0.0)

switch complex{
    case (0, 0):
        print("number is zero")
    case (_, 0):
        print("number is real")
    default:
        print("number is imaginary")
}

enum Sign {
    case Positive, Negative
}

struct ANumber{
    var number:Int
    
    var sign:Sign {
        get{
            return number < 0 ? Sign.Negative : Sign.Positive
        }
        set(newSign){
            if(newSign != self.sign){
                self.number = -self.number
            }
        }
    }
}

var aa = ANumber(number: -3)
aa.sign = Sign.Positive
print(aa.sign)

class OnlyInitialString {
    var initial:String = ""
    var string:String {
        set (newString) {
            if newString.characters.count > 0{
                self.initial = String(newString.characters.first!)
            }else{
                self.initial = ""
            }
        
        }
        get{
            return self.initial
            
        }
    }
}

var aString = OnlyInitialString()
aString.string = "srthsrth"
print(aString.initial)

func calculateStatistics(values:[Int]) -> (min:Int, max:Int, sum:Int, avg:Float){
    var min = values[0]
    var max = values[0]
    var sum = 0
    var avg  :Float
    
    for value in values{
        if value > max {
            max = value
        }else if(value < min){
            min = value
        }
        
        sum += value
    }
    
    avg = Float(sum) / Float(values.count)
    return (max, min, sum, avg)
}

let statistics = calculateStatistics([5, 3, 100, 3, 9])
print(statistics)

func matches(list: [Int], condition:(Int) -> Bool ) -> Bool{
    for item in list{
        if condition(item){
            return true
        }
    }
    return false
}

func lessThanZero(number: Int) -> Bool{
    return number < 0
}

print(matches([2,4,5,-76,0,9,9], condition: lessThanZero))
let array = [2,4,5,-76,0,9,9]

let array2 = array.map {
    return $0*4
}

print(array2)

class Shape {
    var numberOfSides = 0
    let mariano = 7
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
    func test(variable:Int){
    
    }
}

class NamedShape {
    var numberOfSides: Int = 0
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

class Circle : NamedShape {
    var radius: Double
    init(radius: Double, name:String){
        self.radius = radius
        super.init(name: name)
    }
    func area() -> Double{
        return 3.14 * self.radius * self.radius
    }
    override func simpleDescription() -> String {
        return "Circle with area \(area())"
    }
}

let c = Circle(radius: 2, name: "a circle")
print(c.simpleDescription())

Just a few examples of how powerful Swift 2 is :)