natecook1000

let xs = [0,1,2,3,4,5]

let double: (Int) -> Int = { $0 * 2 }

let isEven: (Int) -> Bool = { $0 % 2 == 0 }

// Goal: [0,2,4,6,4,10]. Double all but the last even element.
extension Collection {
    func mapExceptLast(matching predicate: (Element) -> Bool, transform: (Element) -> Element) -> [Element] {
        var result: [Element] = []

natecook1000

func tellJoke(name: String, character: Character) {
    let punchline = String(name.filter { $0 != character })
    let n = name.count - punchline.count
    
    let joke = """
        Q: Why does \(name) have \(n) \(character)'s in their name?
        A: I don't know, why does \(name) have \(n) \(character)'s in their name?
        Q: Because otherwise they'd be called \(punchline).
        """
    print(joke)

natecook1000

import Foundation

public class CoRoutine<T> {
    private var index = 0
    private var sequence : [T]
    private var routine : (T)->()
    private let step : Int?
    private let deltaTime : TimeInterval?
    private(set) public var isCanceled : Bool = false
    private(set) public var isDone : Bool = false

natecook1000

import Darwin
import CoreFoundation

// A variable we can use with exit() to ensure that the optimizer
// doesn't remove code we want to time
var undead = 0 

// A filtered collection that can be more efficiently counted than the stock one.
struct LazyFilterBidirectionalCollection2<Base : BidirectionalCollection> : Collection {
  typealias Impl = LazyFilterBidirectionalCollection<Base>

natecook1000

#!/bin/sh

set -e

if [ -z "${CONFIGURATION}" ]; then
    CONFIGURATION=debug
fi

# Create the development toolchain.
rm -rf ~/public/swift-project/build/Ninja-ReleaseAssert/swift-dev.xctoolchain

natecook1000

protocol FactoryAType {
    typealias Product
}

protocol FactoryBType {
    typealias Product
}

struct CombinedFactory<T: FactoryAType, U: FactoryBType where T.Product == U.Product> {
    let factoryA: T

natecook1000

func modifiedCopy<Struct, Arg>(var start: Struct, @noescape mutator: (inout Struct) -> Arg -> (), arg: Arg) -> Struct {
    mutator(&start)(arg)
    return start
}

extension Array {
    func arrayByAppending(e: Element) -> Array {
        return modifiedCopy(self, mutator: Array.append, arg: e)
    }
}

natecook1000

let string = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Morbi enim lacus, ullamcorper in gravida a, semper id dolor. Mauris quis metus id"

extension String {
    func split(separator: Character, maxSplit: Int = .max, allowEmptySlices: Bool = false) -> [String] {
        return characters.split(separator, maxSplit: maxSplit, allowEmptySlices: allowEmptySlices).map(String.init)
    }
}

let words = try string.split(" ")
let counts = words.map { $0.characters.count }

natecook1000

protocol OptionalType {
    typealias T
    func flatMap<U>(@noescape f: (T) -> U?) -> U?
}

extension Optional : OptionalType { }

extension SequenceType where Generator.Element: OptionalType {
    func flatten() -> [Generator.Element.T] {
        return self.map { $0.flatMap { $0 } }

natecook1000

// see also https://gist.github.com/griotspeak/8bb4c46611fc90d3043b

func findFirst<S: SequenceType>(seq: S, predicate: S.Generator.Element -> Bool) -> S.Generator.Element? {
  for x in seq {
    if predicate(x) { return x }
  }
  return nil
}

func not<T>(predicate: T -> Bool) -> (T -> Bool) {