public protocol MyProtocol: class {
    static func abc()
    init(with str: String) throws
}

public final class MyClass: MyProtocol {
    public enum MyError: Error { case wrongString }

    private let string: String
    public init(with str: String) throws {
        guard str != "ABC" else { throw MyError.wrongString }
        string = str
    }

    public static func abc() { print("Performed ABC!") }
}

import Fmwk1

public protocol SomeBaseProtocol {}

public protocol MySubProtocol: MyProtocol, SomeBaseProtocol {}

internal final class MyIntermediateClass<Underlying: MyProtocol>: MySubProtocol {
    private let underlying: Underlying

    convenience init() throws { try self.init(with: "MyString") }
    init(with str: String) throws { underlying = try Underlying(with: str) }

    static func abc() { Underlying.abc() }
}

public protocol CreatorProtocol: class {
    func createMyType() throws -> MySubProtocol
}

internal final class Creator: CreatorProtocol {
    init() {}

    func createMyType() throws -> MySubProtocol {
        return try MyIntermediateClass<MyClass>()
    }
}

public final class Distributor {
    internal static var creator = Creator()
    public init() {}

    public func createMyType() throws -> MySubProtocol {
        return try type(of: self).creator.createMyType()
    }
}

import Fmwk2

struct Worker {
    private init() {}

    static func work() {
        let myProtocolType: MySubProtocol.Type?
        do {
            myProtocolType = try type(of: Distributor().createMyType())
        } catch {
            myProtocolType = nil
            print("Failed: \(error)")
        }
        myProtocolType?.abc()
        print(myProtocolType.map { "\($0)" } ?? "nil")
    }
}

Worker.work()