Danappelxx

protocol Event {}

protocol ErasedListener {
    func dispatchIfMatches(event: Event)
}

struct Listener<T: Event>: ErasedListener {
    let dispatch: T -> Void
    func dispatchIfMatches(event: Event) {
        (event as? T).flatMap(dispatch)

Danappelxx

let length = 10

let ptr = UnsafeMutablePointer<UInt8>(allocatingCapacity: length)
defer { ptr.deallocateCapacity(length) }

for i in 0..<length {
    ptr.advanced(by: i).pointee = UInt8(i)
}

let buffer = UnsafeMutableBufferPointer(start: ptr, count: length)

Danappelxx

extension String {
    subscript(safe index: String.CharacterView.Index) -> Character? {
        guard index < endIndex else { return nil }
        return self[index]
    }
}

public final class Brainfuck {

    public enum Token {

Danappelxx

//This is the url for my server.
let client = Client(base: "www.myblog.com", method: .GET)

//This is the api path. 
let api = client.endpoint("/api/v1", method: .GET)

//This endpoint builds off of the api endpoint. 
let posts = api.endpoint("/posts", method: .GET)

//This endpoint takes the response from that endpoint, uses it as a parameter for this endpoint

Danappelxx

postfix operator +++ {}

postfix func +++(inout x: Int) -> Int {
    let y = x
    x += 1
    return y
}

var i = 0 // -> 0
i+++ // -> 0

Danappelxx

struct RouteStorage {
    
    var componentsTrie = Trie<Character, Int>()
    var routesTrie = Trie<Int, Route>()
    
    var nextComponentId = 1
    
    init(routes: [Route]) {
        
        for route in routes {

Danappelxx

// Add <https://github.com/samhann/Every.swift/blob/master/NSDateComponentsExtensions.swift> here
import Foundation
import XCPlayground

struct Every {
    
    class Executor: NSObject {
        let closure: NSTimer -> Void
        var timer: NSTimer!
        init(closure: NSTimer -> Void) { self.closure = closure }

Danappelxx

struct Request {}
struct Response {}

enum MiddlewareBeforeResult {
    case Next(Request)
    case Respond(Response)
}

typealias MiddlewareBefore = Request -> MiddlewareBeforeResult
typealias MiddlewareAfter = (Request, Response) -> Response

Danappelxx

struct Task<Input, Output> {
    typealias TaskExecutor =  Input -> Output
    
    let task: TaskExecutor?
    
    var subTasks = [Task<Any,Any>]()
    
    init(task: TaskExecutor? = nil) {
        self.task = task
    }

Danappelxx

enum ReturnType<T> {
    case Normal(T)
    case Early(T)
}

extension SequenceType {
    func rreduce<T>(initial: T, combine: (T, Self.Generator.Element) -> ReturnType<T>) -> T {
        var result = initial
        for el in self {
            switch combine(result, el) {