jarsen

func update<K,V>(var dictionary: [K:V], key: K, value: V) -> [K:V] {
    dictionary[key] = value
    return dictionary
}

func increment<T>(dictionary: [T:Int], key: T) -> [T:Int] {
    return update(dictionary, key, map(dictionary[key]) {$0 + 1} ?? 1)
}

func histogram<T>(var s: [T]) -> [T:Int] {

jarsen

import Cocoa

class CSVDoubleSequence: SequenceType {
    typealias GeneratorType = IndexingGenerator<Array<Double>>
    let path: String
    let values: [Double]
    
    init(path: String) {
        self.path = path
        

jarsen

extension Int {
    class func add1(x: Int) -> Int {
        return  x + 1
    }
    
    func add2() -> Int {
        return self + 2
    }
}

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))

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

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

class EvenNaturalNumbersGenerator : GeneratorType {
    var current = 2

jarsen

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

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

// 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

// TinyWeb OOP(ish) Style

import Foundation

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