jarsen

var animals = ["cow", "dog", "pig"]
var emoji = ["🐮", "🐶", "🐷"]

for (animal, pic) in Zip2(animals, emoji) {
    println("\(animal) \(pic)")
}

jarsen

extension Array {
    func each (block : (T) -> ()) {
        for item in self {
            block(item)
        }
    }
}

animals.each(println)

jarsen

extension NSURL : StringLiteralConvertible {
    public class func convertFromStringLiteral(value: String) -> Self {
        return self(string: value)
    }
    
    public class func convertFromExtendedGraphemeClusterLiteral(value: String) -> Self {
        return self(string: value)
    }
}

jarsen

// TinyWeb OOP(ish) Style

import Foundation

class HTTPResponse {
    let body: String
    let responseCode: Int
    
    init(body: String, responseCode: Int) {
        self.body = body

jarsen

// also see http://oleb.net/blog/2014/07/swift-strings/

// Mark: Strings

// if you want to stringByReplacingOccurrencesOfString without using a nil range, you need to convert to NSString first
var str = "some junk"
let tmpString: NSString = str
str = tmpString.stringByReplacingOccurrencesOfString(" ", withString: "+", options: nil, range: NSMakeRange(1, 6))

// find the length of a swift string

jarsen

class Name : StringLiteralConvertible, Equatable {
    var firstName: String
    var lastName: String
    
    required init(firstName: String, lastName: String) {
        self.firstName = firstName
        self.lastName = lastName
    }
    
    class func convertFromStringLiteral(value: StringLiteralType) -> Self {

jarsen

enum Fallible<T> {
    case Error(NSError)
    case Some(T)
    
    init(value: T) {
        self = .Some(value)
    }
    
    init(error: NSError) {
        self = .Error(error)

jarsen

class EvenNaturalNumbers: SequenceType {
    typealias GeneratorType = EvenNaturalNumbersGenerator
    
    func generate() -> EvenNaturalNumbersGenerator {
        return EvenNaturalNumbersGenerator()
    }
}

class EvenNaturalNumbersGenerator : GeneratorType {
    var current = 2

jarsen

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

import UIKit

typealias Vector2D = (x: Float, y: Float)
typealias Point2D = Vector2D

func -(lhs: Vector2D, rhs: Vector2D) -> Vector2D {
    return (lhs.x - rhs.x, lhs.y - rhs.y)
}

jarsen

func meanSquaredError(predictions: [Double], values: [Double]) -> Double {
    let sum = reduce(Zip2(predictions, values), 0.0) { (acc, y) in
        let diff = y.0 - y.1
        return acc + (diff * diff)
    }
    return sum / Double(predictions.count)
}

// what I want is to bind the arguments in the closure to (acc, (yHat, y))