paulofaria

Now I changed the code to a much simpler one, that simplifies the problem. Whenever I pause with the debugger and p goredump() this is the result.

COROUTINE  state                                      current                                  created
------------------------------------------------------------------------------------------------------------------------
{0}        msleep()                                   /Users/paulofaria/test.c:12              <main>
{1}        RUNNING                                    ---                                      /Users/paulofaria/test.c:11

I tried it in my Linux virtual machine and the same happens. msleep() never returns.

paulofaria

public class EventListener<T> {
    public typealias Listener = T -> ()
    
    private let listener: Listener
    private var calls: Int
    private var active = true
    
    internal init(calls: Int, listener: Listener) {
        self.calls = calls
        self.listener = listener

paulofaria

func foo(closure: Void -> Int) {}

extension Dictionary {
    func bar() {
        var x = 0
        foo { x }
    }
}

paulofaria

func foo(closure: Void -> Int) {}

extension Dictionary {
    func bar() {
        var x = 0
        let y = x
        foo { y }
    }
}

paulofaria

Framework:

struct Request {
    var body: String
}

struct Response {
    var status: String
    var body: String

paulofaria

protocol MiddlewareType {
  func intercept(request: Request, nextResponder: ResponderType) throws -> Response
}

protocol RequestMiddlewareType: MiddlewareType {
  func intercept(request: Request) throws -> Request
}

extension RequestMiddlewareType {
  func intercept(request: Request, nextResponder: ResponderType) throws -> Response {

paulofaria

route.get("/", filters: failureRecoverer, logger, cacher, authenticator, contentNegotiator, templateRenderer, responder: responder)

route.get("/", chain: cacher, authenticator, contentParser, responder, contentSerializer, templateRenderer, logger: logger, failureRecoverer: failureRecoverer)

paulofaria

Source:

struct A {}
struct B {}

let a = A()
let b = B()

func f(a: A..., _ b: B) {}

paulofaria

struct GetPokemonEndpoint: EndpointType {
    let middleware: [MiddlewareType] = [
        debugLogger,
        clientContentNegotiator(JSONMediaType)
    ]

    func serialize(id: Int) throws -> Request {
        return Request(method: .GET, uri: URI(path: "/api/v1/pokemon/\(id)/"))
    }

paulofaria

public protocol RouteType: ResponderType {
    var methods: Set<Method> { get }
    var path: String { get }
    var responder: ResponderType { get }
}

public protocol RouteMatcherType: ResponderType {
    var routes: [RouteType] { get set }
    var fallback: ResponderType { get set }
    func addRouteWithMethods(methods: Set<Method>, path: String, responder: ResponderType)