final class TestViewModel {
    private lazy var userService = getUserService()
    func getData() -> Data {
        return userService.getData()
    }
}
protocol TestViewModelResolving {
    func getUserService() -> UserServiceProtocol
}
extension TestViewModel: TestViewModelResolving {
    func getUserService() -> UserServiceProtocol { return UserService() }
}

final class TestViewModel {
    var userService: UserServiceProtocol?
}
final class UserService:  UserServiceProtocol { … }
…
let viewModel = TestViewModel()
viewModel.userService =  UserService(...)

final class TestView: UIView {
    private var style: ViewStyleProtocol?
    func apply(style: ViewStyleProtocol) {
         self.style = style
         // applying style
    }
}
struct TestViewStyle: ViewStyleProtocol { … }
…
let style = TestViewStyle(...)
testView.apply(style: style)

final class TestViewModel {
    private let userService: UserServiceProtocol
    private let modelId: String
    init(userService: UserServiceProtocol, modelId: String) {
        self.userService = userService
        self.modelId = modelId
    }
    ...
}
final class UserService:  UserServiceProtocol { … }
…
let userService = UserService(...)
let viewModel = TestViewModel(userService: userService, modelId: “id”)

protocol ServiceLocating {
    func resolve<T>() -> T?
}
final class ServiceLocator: ServiceLocating {
    static let shared = ServiceLocator() // Singleton
    // MARK: Private properties
    private lazy var services = [String: Any]()
    // MARK: Init
    private init() {}
    // MARK: Private methods
    private func typeName(_ some: Any) -> String {
        return (some is Any.Type) ? "\(some)" : "\(type(of: some))"
    }
    // MARK: Internal methods
    func register<T>(service: T) {
        let key = typeName(T.self)
        services[key] = service
    }
    func resolve<T>() -> T? {
        let key = typeName(T.self)
        return services[key] as? T
    }
}

func someMethod() {
    let service = TestService()
    // используем service
}

ServiceLocator.shared.register(service: service)
…
func someMethod() {
    guard let service: TestServiceProtocol = ServiceLocator.shared.resolve() else {
        return
    }
    // используем service
}

final class SomeClass {
    private let userService: UserServiceProtocol
    init(serviceLocator: ServiceLocating) {
        userService = serviceLocator.resolve()!
    }
}

final class UserProfileFactory {
    static func createUserProfile(serviceLocator: ServiceLocating) -> UIViewController {
        let viewController = UserProfileViewController()
        let userService: UserServiceProtocol = serviceLocator.resolve()!
        let viewModel = UserProfileViewModel(userService: userService)
        viewController.viewModel = viewModel
        return viewController
    }
}

protocol Animal {
    var name: String { get }
}
final class Cat: Animal {
    let name: String
    init(name: String) {
        self.name = name
    }
}
...
let container = Container()
container.register(Animal.self) { _ in Cat(name: "Mimi") }
...
let animal = container.resolve(Animal.self)!
print(animal.name) //prints “mimi”

public final class Container {
    internal var services = [ServiceKey: ServiceEntryProtocol]()
    ...
}
internal struct ServiceKey {
    internal let serviceType: Any.Type
    internal let argumentsType: Any.Type
    internal let name: String?
    internal let option: ServiceKeyOption? // Used for SwinjectStoryboard or other extensions.
    ...
}

internal protocol ServiceEntryProtocol: AnyObject {
    func describeWithKey(_ serviceKey: ServiceKey) -> String
    var objectScope: ObjectScopeProtocol { get }
    var storage: InstanceStorage { get }
    var factory: FunctionType { get }
    var initCompleted: (FunctionType)? { get }
    var serviceType: Any.Type { get }
}

final class A {
  private let b: B
  init(b: B) {
      self.b = b
  }
}
final class B {
  private let c: C
  init(c: C) {
      self.c = c
  }
}
final class C {
  private let a: A
  init(a: A) {
      self.a = a
  }
}
let container = Container()
container.register(A.self) { r in 
   return A(b: r.resolve(B.self)!)
}
container.register(B.self) { r in 
   return B(c: r.resolve(C.self)!)
}
container.register(C.self){ r in 
   return C(a: r.resolve(A.self)!)
}
...
let a1 = container.resolve(A.self)!
let a2 = container.resolve(A.self)!

container.register(A.self) { r in 
   return A(b: r.resolve(B.self)!)
}
.inObjectScope(.transient)

container.register(B.self) { r in 
   return B(c: r.resolve(C.self)!)
}
.inObjectScope(.container)

final class C {
  var a: A?
}
container.register(C.self) { _ in return C() }
    .initCompleted { r, c in
        c.a = r.resolve(A.self)
    }

container.register(MyServiceProtocol.self) { r in 
    MyService(dependencyA: r.resolve(DependencyA.self)!, 
              dependencyB: r.resolve(DependencyB.self)!, 
              dependencyC: r.resolve(DependencyC.self)!, 
              dependencyD: r.resolve(DependencyD.self)!)
}

container.autoregister(MyServiceProtocol.self, initializer: MyService.init)

prefix operator <?
prefix func <? <Service>(_ resolver: Resolver) -> Service? {
    return resolver.resolve(Service.self)
}
prefix operator <~
prefix func <~ <Service>(_ resolver: Resolver) -> Service {
    return (<?resolver)!
}

container.register(MyServiceProtocol.self) { r in 
    MyService(dependencyA: <~r, 
              dependencyB: <~r, 
              dependencyC: <~r, 
              dependencyD: <~r)
}

let threadSafeContainer: Resolver = container.synchronize()

let container = DependencyContainer()
container.register { ServiceImp() as Service }
...
let service = try! container.resolve() as Service

public final class DependencyContainer {
  ...
  var definitions = [DefinitionKey: _Definition]()
  ...
}

public struct DefinitionKey: Hashable, CustomStringConvertible {
  public let type: Any.Type
  public let typeOfArguments: Any.Type
  public private(set) var tag: DependencyContainer.Tag?
  ...
}

let container = DIContainer()
container.register(MyService.init).as(MyServiceProtocol.self)
...
let router: MyServiceProtocol = container.resolve()

#if DEBUG
if !container.makeGraph().checkIsValid(checkGraphCycles: true) {
    fatalError("invalid graph")
}
#endif

public protocol DIStorage {
     /// Return all storaged object if there is.
     var any: [DIComponentInfo: Any] { get }
     ...
}
/// Short information about component. Needed for good log
public struct DIComponentInfo: Hashable, CustomStringConvertible {
     /// Any type announced at registration the component
     public let type: DIAType
     /// File where the component is registration
     public let file: String
     /// Line where the component is registration
     public let line: Int
     ...
}

final class ServiceAssembly: Assembly {
    var apiClient: APIClient {
      return define(init: APIClient())
    }
}

public final class DIContext {
    public static var defaultInstance = DIContext()
    fileprivate var assemblies: [String: Assembly] = [:]
    var objectGraphStorage: [String: InjectableObject] = [:]
    ...
}

public typealias InjectableObject = Any

protocol MyDependency: Dependency {
    var chocolate: Food { get }
    var milk: Food { get }
}
final class MyComponent: Component<MyDependency> {
    var hotChocolate: Drink {
        return HotChocolate(dependency.chocolate, dependency.milk)
    }
    var myChildComponent: MyChildComponent {
        return MyChildComponent(parent: self)
    }
}

final class MyClass {
    // weaver: movieManager = MovieManager <- MovieManaging
    // weaver: movieManager.scope = .container
    ...
}

final class MyClass {
    @Weaver(.registration, type: MovieManager.self, scope: .container)
    private var movieManager: MovieManaging
    ...
}

// weaver: dependencyName = DependencyConcreteType <- DependencyProtocol
@Weaver(.registration, type: DependencyConcreteType.self) 
var dependencyName: DependencyProtocol

// weaver: dependencyName <- DependencyType
@Weaver(.reference) 
var dependencyName: DependencyType

// weaver: parameterName <= ParameterType
@Weaver(.parameter) 
var parameterName: ParameterType

required init(injecting _: MyDependencyResolver) {
    // no-op
}