     
     public final func scoped<T>(name: String = #function, _ factory: @autoclosure () -> T, configure: ((T) -> Void)? = nil) -> T {
         return inject(
-            lifecyle: .Scoped,
+            lifecyle: .scoped,
             name: name,
-            instancePool: &scopedInstances,
-            containerFactory: { StrongContainer(instance: $0) },
+            instances: &scopedInstances,
             factory: factory,
             configure: configure
         )
     }
     
-    fileprivate final func inject<T, C: InstanceContainer>(lifecyle: Lifecyle, name: String, instancePool: inout [String:AnyObject], containerFactory: (T) -> C, factory: @autoclosure () -> T, configure: ((T) -> Void)?) -> T where C.InstanceType == T {
-        if let container = instancePool[name] as? C {
-            if let instance = container.instance {
-                return instance
-            }
+    private final func inject<T>(lifecyle: Lifecyle, name: String, instances: inout [String:Any], factory: () -> T, configure: ((T) -> Void)?) -> T {
+        if let instance = instances[name] as? T {
+            return instance
         }
         
         let key = InstanceKey(lifecycle: lifecyle, name: name)
         
-        if lifecyle != .Unshared && instanceStack.contains(key) {
+        if lifecyle != .unshared && instanceStack.contains(key) {
             fatalError("Circular dependency from one of \(instanceStack) to \(key) in initializer")
         }
         

        var description: String {
            return "\(lifecycle)(\(name))"
        }
    }
    
    fileprivate var sharedInstances: [String:AnyObject] = [:]
    fileprivate var weakSharedInstances: [String:AnyObject] = [:]
    fileprivate var scopedInstances: [String:AnyObject] = [:]
    fileprivate var instanceStack: [InstanceKey] = []
    fileprivate var configureStack: [() -> ()] = []
    fileprivate var requestDepth = 0
    
    public init() { }
    

    }
    
    public final func weakShared<T: AnyObject>(name: String = #function, _ factory: @autoclosure () -> T, configure: ((T) -> Void)? = nil) -> T {
        var instance: T! // Keep instance alive for duration of method
        let weakInstance: Weak<T> = inject(
            lifecyle: .weakShared,
            name: name,
            instances: &weakSharedInstances,
            factory: {
                instance = factory()
                return Weak(instance)
            },
            configure: { configure?($0.instance!) }
        )
        return weakInstance.instance!
    }
    
    public final func unshared<T>(name: String = #function, factory: () -> T, configure: ((T) -> Void)? = nil) -> T {
