     static let sharedInstance = ServiceLocator()
     
     private var services = [String : Any]()
-    private lazy var lazyServices = [String : LazyServiceClosure<Any>]()
+    private var lazyServiceInits = [String : LazyServiceClosure<Any>]()
     
     // MARK: - Public Methods
     
-    func register<Service>(service: Service, serviceName: String? = nil) throws {
+    func register<Service>(name serviceName: String? = nil, service: Service) throws {
         let name = buildName(for: Service.self, serviceName)
         
-        try register(service: service, name: name)
+        try checkForDuplicateService(with: name)
+        
+        services[name] = service
     }
     
-    func register<Service>(serviceName: String? = nil, _ lazyInit: @escaping LazyServiceClosure<Service>) throws {
+    func register<Service>(name serviceName: String? = nil, _ lazyInit: @escaping LazyServiceClosure<Service>) throws {
         let name = buildName(for: Service.self, serviceName)
         
-        try register(serviceName: name, lazyInit)
+        try checkForDuplicateService(with: name)
+        
+        lazyServiceInits[name] = lazyInit
     }
     
-    func unregister<Service>(_: Service, serviceName: String? = nil) throws {
+    func unregister<Service>(_: Service, name serviceName: String? = nil) throws {
         let name = buildName(for: Service.self, serviceName)
         
+        guard let anyService = services[name] ?? lazyServiceInits[name]?() else {
+            throw ServiceLocatorError.inexistentService
+        }
+        
+        guard let _ = anyService as? Service else {
+            throw ServiceLocatorError.serviceTypeMismatch(expected: "\(Service.self)", found: "\(type(of: anyService))")
+        }
+        
         services[name] = nil
-        lazyServices[name] = nil
+        lazyServiceInits[name] = nil
     }
     
     func unregisterAll() {
         services.removeAll()
-        lazyServices.removeAll()
+        lazyServiceInits.removeAll()
     }
     
-    func get<Service>(serviceName: String? = nil) throws -> Service {
-        let name = buildName(for: Service.self, serviceName)
-        
-        return try locateAndRegister(serviceName: name)
+    func get<Service>(name serviceName: String? = nil) throws -> Service {
+        return try locate(serviceName)
     }
     
     // MARK: - Private Methods
     
-    private func register<Service>(service: Service, name: String) throws {
-        try checkForDuplicatedService(for: name)
-        
-        services[name] = service
-    }
-    
-    private func register<Service>(serviceName: String, _ lazyInit: @escaping LazyServiceClosure<Service>) throws {
-        try checkForDuplicatedService(for: serviceName)
-        
-        lazyServices[serviceName] = lazyInit
-    }
-    
-    private func locateAndRegister<Service>(serviceName: String) throws -> Service {
-        if let lazyServiceClosure = lazyServices[serviceName] {
-            // Remove closure since this is already initialised
-            lazyServices[serviceName] = nil
-            
+    private func locate<Service>(_ serviceName: String? = nil) throws -> Service {
+        let name = buildName(for: Service.self, serviceName)
+        if let lazyServiceClosure = lazyServiceInits[name] {
             let service: Service = try checkIfServiceValid(lazyServiceClosure())
             
-            try register(service: service, name: serviceName)
+            // Remove closure since the service is now validated
+            lazyServiceInits[name] = nil
+            
+            // This should *never* fail unless we have some name collision bug, so 💥 immediately
+            try! register(name: name, service: service)
         }
         
-        return try locate(serviceName: serviceName)
-    }
-    
-    private func locate<Service>(serviceName: String) throws -> Service {
-        guard let anyService = services[serviceName] else {
+        guard let anyService = services[name] else {
             throw ServiceLocatorError.inexistentService
         }
         

    
    private func checkIfServiceValid<Service>(_ anyService: Any) throws -> Service {
        guard let service = anyService as? Service else {
            throw ServiceLocatorError.serviceTypeMismatch
        }
        
        return service
    }
    
    private func checkForDuplicatedService(`for` name: String) throws {
        guard services[name] == nil else {
            throw ServiceLocatorError.duplicateService(name)
        }
        
        guard services[name] == nil else {
            throw ServiceLocatorError.lazyDuplicatedService(name)
        }
    }
}

public enum ServiceLocatorError: Error {
    case duplicateService(String)
    case inexistentService
    case serviceTypeMismatch(expected: String, found: String)
    case duplicateLazyServiceInit(String)
}

public final class ServiceLocator {
