             }
         }
 
-        func simple(_ method: Method, subpath: String? = nil, _ simple: Resource<Model>.SimpleRequest?) {
-            guard let simple = simple else {
+        func multiple(_ method: Method, subpath: String? = nil, _ multiple: Resource<Model>.Multiple?) {
+            guard let multiple = multiple else {
                 return
             }
 
-            simpleMethods += method
+            multipleMethods += method
 
             if let subpath = subpath {
                 self.add(method, path, subpath) { request in
-                    return try simple(request).makeResponse()
+                    return try multiple(request).makeResponse()
                 }
             } else {
                 self.add(method, path) { request in
-                    return try simple(request).makeResponse()
+                    return try multiple(request).makeResponse()
                 }
             }
         }
 
-        simple(.get, resource.index)
-        simple(.get, subpath: "new", resource.new)
+        multiple(.get, resource.index)
+        multiple(.get, subpath: "new", resource.new)
         item(.get, subpath: "edit", resource.edit)
-        simple(.post, resource.create)
+        multiple(.post, resource.create)
         item(.get, resource.show)
         item(.put, resource.replace)
         item(.patch, resource.update)
         item(.delete, resource.destroy)
-        simple(.delete, resource.clear)
+        multiple(.delete, resource.clear)
 
         if let about = resource.aboutItem {
             item(.options, about)

        }

        if let about = resource.aboutMultiple {
            simple(.options, about)
        } else {
            simple(.options) { request in
                let methods: [String] = simpleMethods.map { $0.description }
                return try JSON(node: [
                    "resource": path,
                    "methods": try JSON(node: methods)

import TypeSafeRouting

public final class Resource<Model: StringInitializable> {
    public typealias Multiple = (Request) throws -> ResponseRepresentable
    public typealias Item = (Request, Model) throws -> ResponseRepresentable

    public var index: Multiple?
    public var new: Multiple?
    public var create: Multiple?
    public var show: Item?
    public var edit: Item?
    public var update: Item?
    public var replace: Item?
    public var destroy: Item?
    public var clear: Multiple?
    public var aboutItem: Item?
    public var aboutMultiple: Multiple?

    public init(
        index: Multiple? = nil,
        new: Multiple? = nil,
        create: Multiple? = nil,
        show: Item? = nil,
        edit: Item? = nil,
        update: Item? = nil,
        replace: Item? = nil,
        destroy: Item? = nil,
        clear: Multiple? = nil,
        aboutItem: Item? = nil,
        aboutMultiple: Multiple? = nil
        ) {
        self.index = index
        self.new = new
