 	func resolve<T, Method>(_ container: DIContainer, type: T.Type, method: @escaping (Method) -> Any) throws -> T {
 		let rTypes = try check(type: type)
 
-		let index = rTypes.count <= 1 ? 0 : rTypes.index(where: { $0.isDefault })!
+		let index = 1 == rTypes.count ? 0 : rTypes.index(where: { $0.isDefault })!
     return try resolveUseRType(container, pair: RTypeWithName(rTypes[index]), method: method)
   }
 
   func resolveMany<T, Method>(_ container: DIContainer, type: T.Type, method: @escaping (Method) -> Any) throws -> [T] {
     let rTypes = try getTypes(type)
-
-    var result: [T] = []
-    for rType in rTypes {
+    
+    return try rTypes.map { rType in
       do {
-        try result.append(resolveUseRType(container, pair: RTypeWithName(rType), method: method))
+        return try resolveUseRType(container, pair: RTypeWithName(rType), method: method)
       } catch DIError.recursiveInitialization {
-        // Ignore recursive initialization object for many
-      } catch {
-        throw error
+        return nil // Ignore recursive initialization object for many
       }
-    }
-
-    return result
+    }.filter{ $0 != nil }.map{ $0! }
   }
 
   func resolve<T, Method>(_ container: DIContainer, name: String, type: T.Type, method: @escaping (Method) -> Any) throws -> T {

	func check<T>(name: String, type: T.Type) throws -> [RTypeFinal] {
		let rTypes = try getTypes(type)
		
		if !rTypes.contains(where: { $0.has(name: name)}) {
			throw DIError.typeIsNotFoundForName(type: type, name: name, typesInfo: rTypes.map { $0.typeInfo })
		}
		

  }

  private func resolveSingle<T, Method>(_ container: DIContainer, pair: RTypeWithName, method: @escaping (Method) -> Any) throws -> T {
    return try _resolveUniversal(container, pair: pair, method: method,
                                 get: { Cache.single[$0] },
                                 set: { Cache.single[$0] = $1 })
  }
  
  private func resolveWeakSingle<T, Method>(_ container: DIContainer, pair: RTypeWithName, method: @escaping (Method) -> Any) throws -> T {
