diff --git a/Sources/DispatchQueue+Jetpack.swift b/Sources/DispatchQueue+Jetpack.swift
index 94daed2..703c778 100644
--- a/Sources/DispatchQueue+Jetpack.swift
+++ b/Sources/DispatchQueue+Jetpack.swift
@@ -7,13 +7,13 @@ import Foundation
 
 extension DispatchQueue {
 
-    func jx_asyncAfter(deadline: DispatchTime, execute work: @escaping ()->Void) ->  Disposable {
+    func jx_asyncAfter(deadline: DispatchTime, execute work: @escaping () -> Void) -> Disposable {
         let item = DispatchWorkItem(block: work)
         asyncAfter(deadline: deadline, execute: item)
         return BlockDisposable { item.cancel() }
     }
     
-    func jx_async(execute work: @escaping ()->Void) ->  Disposable {
+    func jx_async(execute work: @escaping () -> Void) -> Disposable {
         let item = DispatchWorkItem(block: work)
         async(execute: item)
         return BlockDisposable { item.cancel() }
diff --git a/Sources/MetaProperty.swift b/Sources/MetaProperty.swift
index 340c1fd..3147542 100644
--- a/Sources/MetaProperty.swift
+++ b/Sources/MetaProperty.swift
@@ -11,13 +11,13 @@ public protocol ChangeEventProtocol {
 
 public final class MetaProperty<T, Event: ChangeEventProtocol>: ObserveValueProtocol, GetValueProtocol {
     private let observable: Observable<(T, Event)>
-    private let getter: ()->T
+    private let getter: () -> T
 
     public var value: T {
         return getter()
     }
 
-    init(observable: Observable<(T, Event)>, getter: @escaping ()->T) {
+    init(observable: Observable<(T, Event)>, getter: @escaping () -> T) {
         self.getter = getter
         self.observable = observable
     }
diff --git a/Sources/MutableMetaProperty.swift b/Sources/MutableMetaProperty.swift
index 499c547..8fbb457 100644
--- a/Sources/MutableMetaProperty.swift
+++ b/Sources/MutableMetaProperty.swift
@@ -46,7 +46,7 @@ open class MutableMetaProperty<T, Event: ChangeEventProtocol>: ObserveValueProto
         }
     }
 
-    public func mutateWithEvent(_ transform: (inout T)-> Event) {
+    public func mutateWithEvent(_ transform: (inout T) -> Event) {
         mutateLock.synchronized {
             
             let (newValue, newEvent): (T, Event
diff --git a/Sources/Observable+Common.swift b/Sources/Observable+Common.swift
index 59405e9..b3c8367 100644
--- a/Sources/Observable+Common.swift
+++ b/Sources/Observable+Common.swift
@@ -7,7 +7,7 @@ import Foundation
 
 extension ObserveValueProtocol {
     
-    public func map<U>(_ transform: @escaping (ValueType)-> U) -> Observable<U> {
+    public func map<U>(_ transform: @escaping (ValueType) -> U) -> Observable<U> {
         return Observable { observer in
             return self.subscribe { result in
                 observer(transform(result))
@@ -19,7 +19,7 @@ extension ObserveValueProtocol {
         return map { $0[keyPath: keyPath] }
     }
     
-    public func compactMap<U>(_ transform: @escaping (ValueType)-> U?) -> Observable<U> {
+    public func compactMap<U>(_ transform: @escaping (ValueType) -> U?) -> Observable<U> {
         return Observable { observer in
             return self.subscribe { result in
                 if let newResult = transform(result) {
@@ -120,7 +120,7 @@ extension ObserveValueProtocol {
         }
     }
 
-    public func take(while f: @escaping (ValueType)->Bool) -> Observable<ValueType> {
+    public func take(while f: @escaping (ValueType) -> Bool) -> Observable<ValueType> {
         return Observable { observer in
             var canEmit = true
             var disposable: Disposable?
diff --git a/Sources/Observable+DispatchQueue.swift b/Sources/Observable+DispatchQueue.swift
index 964e867..a27ed83 100644
--- a/Sources/Observable+DispatchQueue.swift
+++ b/Sources/Observable+DispatchQueue.swift
@@ -9,13 +9,13 @@
 import Foundation
 
 extension ObserveValueProtocol {
-    public func delay(timeInterval: TimeInterval, on queue: DispatchQueue) ->  Observable<ValueType> {
+    public func delay(timeInterval: TimeInterval, on queue: DispatchQueue) -> Observable<ValueType> {
         return flatMapLatest { value in
             return Observable.delayed(value, timeInterval: timeInterval, on: queue)
         }
     }
     
-    public func dispatch(on queue: DispatchQueue) ->  Observable<ValueType> {
+    public func dispatch(on queue: DispatchQueue) -> Observable<ValueType> {
         return flatMapLatest { value in
             return Observable.dispatched(value, on: queue)
         }
diff --git a/Sources/Observable.swift b/Sources/Observable.swift
index fcd4fd8..d636657 100755
--- a/Sources/Observable.swift
+++ b/Sources/Observable.swift
@@ -29,14 +29,8 @@ public final class Observable<T>: ObserveValueProtocol {
 }
 
 extension Observable {
-
-    public static func performed(workerQueue: DispatchQueue, completionQueue: DispatchQueue, worker: @escaping () -> T) ->  Observable<T> {
-        return Observable<Void>.dispatched((), on: workerQueue)
-            .map(worker)
-            .dispatch(on: completionQueue)
-    }
     
-    public static func delayed(_ value: T, timeInterval: TimeInterval, on queue: DispatchQueue) ->  Observable<T> {
+    public static func delayed(_ value: T, timeInterval: TimeInterval, on queue: DispatchQueue) -> Observable<T> {
         return Observable { observer in
             return queue.jx_asyncAfter(deadline: .now() + timeInterval) {
                 observer(value)
@@ -68,7 +62,7 @@ extension Observable {
         }
     }
     
-    public static func dispatched(_ value: T, on queue: DispatchQueue) ->  Observable<T> {
+    public static func dispatched(_ value: T, on queue: DispatchQueue) -> Observable<T> {
         return Observable { observer in
             if queue == .main && Thread.isMainThread {
                 observer(value)
@@ -81,6 +75,10 @@ extension Observable {
         }
     }
     
+    public static func performed(on queue: DispatchQueue, worker: @escaping () -> T) -> Observable<T> {
+        return Observable<Void>.dispatched((), on: queue).map(worker)
+    }
+    
     public static func just(_ value: T) -> Observable<T> {
         return Observable { observer in
             observer(value)
@@ -94,7 +92,7 @@ extension Observable {
         }
     }
     
-    public static func deferred(_ f: @escaping ()->T) -> Observable<T> {
+    public static func deferred(_ f: @escaping () -> T) -> Observable<T> {
         return Observable { observer in
             observer(f())
             return EmptyDisposable()
@@ -103,7 +101,7 @@ extension Observable {
 }
 
 extension Observable where T == Void {
-    public static func delayed(timeInterval: TimeInterval, on queue: DispatchQueue) ->  Observable<Void> {
+    public static func delayed(timeInterval: TimeInterval, on queue: DispatchQueue) -> Observable<Void> {
         return Observable.delayed((), timeInterval: timeInterval, on: queue)
     }
        
diff --git a/Sources/Property.swift b/Sources/Property.swift
index 4436688..79d2896 100755
--- a/Sources/Property.swift
+++ b/Sources/Property.swift
@@ -9,13 +9,13 @@ import Foundation
 public final class Property<T>: ObserveValueProtocol , GetValueProtocol {
     
     private let observable: Observable<T>
-    private let getter: ()->T
+    private let getter: () -> T
     
     public var value: T {
         return getter()
     }
     
-    init(observable: Observable<T>, getter: @escaping ()->T) {
+    init(observable: Observable<T>, getter: @escaping () -> T) {
         self.getter = getter
         self.observable = observable
     }
@@ -36,7 +36,7 @@ public final class Property<T>: ObserveValueProtocol , GetValueProtocol {
         return observable.subscribe(observer)
     }
     
-    public func map<U>(_ transform: @escaping (ValueType)-> U) -> Property<U> {
+    public func map<U>(_ transform: @escaping (ValueType) -> U) -> Property<U> {
         return Property<U>(observable: map(transform)) {
             return transform(self.getter())
         }
@@ -46,7 +46,7 @@ public final class Property<T>: ObserveValueProtocol , GetValueProtocol {
         return map { $0[keyPath: keyPath] }
     }
     
-    public func compactMap<U>(_ transform: @escaping (T)-> U?) -> Property<U?> {
+    public func compactMap<U>(_ transform: @escaping (T) -> U?) -> Property<U?> {
         return Property<U?>(observable: compactMap(transform).map { Optional.some($0) }, initialValue: transform(value))
     }
     
diff --git a/Sources/UnsafeSubject.swift b/Sources/UnsafeSubject.swift
index c82d816..6d02034 100644
--- a/Sources/UnsafeSubject.swift
+++ b/Sources/UnsafeSubject.swift
@@ -12,7 +12,7 @@ final class UnsafeSubject<T> {
 
     private struct ObserverHolder<T> {
         let token: UInt
-        let observer: (T)->Void
+        let observer: (T) -> Void
     }
     
     private var observers: [ObserverHolder<T>] = []
diff --git a/Tests/JetpackTests/JetpackTests.swift b/Tests/JetpackTests/JetpackTests.swift
index 8a27afd..8ba11b0 100755
--- a/Tests/JetpackTests/JetpackTests.swift
+++ b/Tests/JetpackTests/JetpackTests.swift
@@ -819,8 +819,8 @@ class JetpackTests: XCTestCase {
     
     private func stressTest(numberOfQueues: Int,
                             numberOfIterations: Int,
-                            when: @escaping ()->Void,
-                            then: ()->Void) {
+                            when: @escaping () -> Void,
+                            then: () -> Void) {
 
         let group = DispatchGroup()