 /// Executor encapsulates asynchrounous way of execution escaped block.
 public struct Executor {
   public typealias Handler = (@escaping (Void) -> Void) -> Void
-  private let _handler: Handler
+  private let _impl: ExecutorImpl
+
+  init(impl: ExecutorImpl) {
+    _impl = impl
+  }
 
   /// Initialiaes executor with custom handler
   public init(handler: @escaping Handler) {
-    _handler = handler
+    _impl = HandlerBasedExecutorImpl(handler: handler)
   }
 
   func execute(_ block: @escaping (Void) -> Void) {
-    _handler(block)
+    _impl.fc_execute(block)
   }
 
   func execute(after timeout: Double, _ block: @escaping (Void) -> Void) {
-    let deadline = DispatchWallTime.now() + .nanoseconds(Int(timeout * 1000 * 1000 * 1000))
-    DispatchQueue.global(qos: .default).asyncAfter(wallDeadline: deadline) {
-      self.execute(block)
-    }
+    _impl.fc_execute(after: timeout, block)
   }
 }
 

    return Executor.queue(DispatchQueue.global(qos: qos))
  }
}


  /// initializes executor based on specified queue
  static func queue(_ queue: DispatchQueue) -> Executor {
    return Executor(impl: queue)
  }

  /// initializes executor based on global queue with specified QoS class
