diff --git a/README.md b/README.md
index d226fb6..3b04e2e 100644
--- a/README.md
+++ b/README.md
@@ -32,10 +32,10 @@ Objective-C and Swift to facilitate writing asynchronous code.
     *   [Always](g3doc/index.md#always)
     *   [Any](g3doc/index.md#any)
     *   [Recover](g3doc/index.md#recover)
-    *   [Resolve](g3doc/index.md#resolve)
     *   [Timeout](g3doc/index.md#timeout)
     *   [Validate](g3doc/index.md#validate)
     *   [When](g3doc/index.md#when)
+    *   [Wrap](g3doc/index.md#wrap)
 *   [Advanced topics](g3doc/index.md#advanced-topics)
     *   [Default dispatch queue](g3doc/index.md#default-dispatch-queue)
     *   [Ownership and retain
diff --git a/Sources/FBLPromises/FBLPromise+Always.m b/Sources/FBLPromises/FBLPromise+Always.m
index 0951f1e..f141d53 100644
--- a/Sources/FBLPromises/FBLPromise+Always.m
+++ b/Sources/FBLPromises/FBLPromise+Always.m
@@ -20,11 +20,11 @@
 
 @implementation FBLPromise (AlwaysAdditions)
 
-- (FBLPromise *)always:(void (^)(void))work {
+- (FBLPromise *)always:(FBLPromiseAlwaysWorkBlock)work {
   return [self onQueue:FBLPromise.defaultDispatchQueue always:work];
 }
 
-- (FBLPromise *)onQueue:(dispatch_queue_t)queue always:(void (^)(void))work {
+- (FBLPromise *)onQueue:(dispatch_queue_t)queue always:(FBLPromiseAlwaysWorkBlock)work {
   NSParameterAssert(queue);
   NSParameterAssert(work);
 
@@ -43,14 +43,14 @@
 
 @implementation FBLPromise (DotSyntax_AlwaysAdditions)
 
-- (FBLPromise* (^)(void (^)(void)))always {
-  return ^(void (^work)(void)) {
+- (FBLPromise* (^)(FBLPromiseAlwaysWorkBlock))always {
+  return ^(FBLPromiseAlwaysWorkBlock work) {
     return [self always:work];
   };
 }
 
-- (FBLPromise* (^)(dispatch_queue_t, void (^)(void)))alwaysOn {
-  return ^(dispatch_queue_t queue, void (^work)(void)) {
+- (FBLPromise* (^)(dispatch_queue_t, FBLPromiseAlwaysWorkBlock))alwaysOn {
+  return ^(dispatch_queue_t queue, FBLPromiseAlwaysWorkBlock work) {
     return [self onQueue:queue always:work];
   };
 }
diff --git a/Sources/FBLPromises/FBLPromise+Recover.m b/Sources/FBLPromises/FBLPromise+Recover.m
index 1717efd..0c9326a 100644
--- a/Sources/FBLPromises/FBLPromise+Recover.m
+++ b/Sources/FBLPromises/FBLPromise+Recover.m
@@ -20,11 +20,11 @@
 
 @implementation FBLPromise (RecoverAdditions)
 
-- (FBLPromise *)recover:(nullable id (^)(NSError *))recovery {
+- (FBLPromise *)recover:(FBLPromiseRecoverWorkBlock)recovery {
   return [self onQueue:FBLPromise.defaultDispatchQueue recover:recovery];
 }
 
-- (FBLPromise *)onQueue:(dispatch_queue_t)queue recover:(nullable id (^)(NSError *))recovery {
+- (FBLPromise *)onQueue:(dispatch_queue_t)queue recover:(FBLPromiseRecoverWorkBlock)recovery {
   NSParameterAssert(queue);
   NSParameterAssert(recovery);
 
@@ -39,14 +39,14 @@
 
 @implementation FBLPromise (DotSyntax_RecoverAdditions)
 
-- (FBLPromise * (^)(id __nullable (^)(NSError *)))recover {
-  return ^(FBLPromise * (^recovery)(NSError *)) {
+- (FBLPromise * (^)(FBLPromiseRecoverWorkBlock))recover {
+  return ^(FBLPromiseRecoverWorkBlock recovery) {
     return [self recover:recovery];
   };
 }
 
-- (FBLPromise * (^)(dispatch_queue_t, id __nullable (^)(NSError *)))recoverOn {
-  return ^(dispatch_queue_t queue, id __nullable (^recovery)(NSError *)) {
+- (FBLPromise * (^)(dispatch_queue_t, FBLPromiseRecoverWorkBlock))recoverOn {
+  return ^(dispatch_queue_t queue, FBLPromiseRecoverWorkBlock recovery) {
     return [self onQueue:queue recover:recovery];
   };
 }
diff --git a/Sources/FBLPromises/FBLPromise+Validate.m b/Sources/FBLPromises/FBLPromise+Validate.m
index 46eaafb..10a5c10 100644
--- a/Sources/FBLPromises/FBLPromise+Validate.m
+++ b/Sources/FBLPromises/FBLPromise+Validate.m
@@ -20,11 +20,11 @@
 
 @implementation FBLPromise (ValidateAdditions)
 
-- (FBLPromise *)validate:(BOOL (^)(id __nullable))predicate {
+- (FBLPromise *)validate:(FBLPromiseValidateWorkBlock)predicate {
   return [self onQueue:FBLPromise.defaultDispatchQueue validate:predicate];
 }
 
-- (FBLPromise *)onQueue:(dispatch_queue_t)queue validate:(BOOL (^)(id __nullable))predicate {
+- (FBLPromise *)onQueue:(dispatch_queue_t)queue validate:(FBLPromiseValidateWorkBlock)predicate {
   NSParameterAssert(queue);
   NSParameterAssert(predicate);
 
@@ -40,14 +40,14 @@
 
 @implementation FBLPromise (DotSyntax_ValidateAdditions)
 
-- (FBLPromise* (^)(BOOL (^)(id __nullable)))validate {
-  return ^(BOOL (^predicate)(id __nullable)) {
+- (FBLPromise* (^)(FBLPromiseValidateWorkBlock))validate {
+  return ^(FBLPromiseValidateWorkBlock predicate) {
     return [self validate:predicate];
   };
 }
 
-- (FBLPromise* (^)(dispatch_queue_t, BOOL (^)(id __nullable)))validateOn {
-  return ^(dispatch_queue_t queue, BOOL (^predicate)(id __nullable)) {
+- (FBLPromise* (^)(dispatch_queue_t, FBLPromiseValidateWorkBlock))validateOn {
+  return ^(dispatch_queue_t queue, FBLPromiseValidateWorkBlock predicate) {
     return [self onQueue:queue validate:predicate];
   };
 }
diff --git a/Sources/FBLPromises/include/FBLPromise+Always.h b/Sources/FBLPromises/include/FBLPromise+Always.h
index 4051035..8747315 100644
--- a/Sources/FBLPromises/include/FBLPromise+Always.h
+++ b/Sources/FBLPromises/include/FBLPromise+Always.h
@@ -20,18 +20,21 @@ NS_ASSUME_NONNULL_BEGIN
 
 @interface FBLPromise<Value>(AlwaysAdditions)
 
+typedef void (^FBLPromiseAlwaysWorkBlock)(void) NS_SWIFT_UNAVAILABLE("");
+
 /**
  @param work A block that always executes, no matter if the receiver is rejected or fulfilled.
  @return A new pending promise to be resolved with same resolution as the receiver.
  */
-- (FBLPromise *)always:(void (^)(void))work NS_SWIFT_UNAVAILABLE("");
+- (FBLPromise *)always:(FBLPromiseAlwaysWorkBlock)work NS_SWIFT_UNAVAILABLE("");
 
 /**
  @param queue A queue to dispatch on.
  @param work A block that always executes, no matter if the receiver is rejected or fulfilled.
  @return A new pending promise to be resolved with same resolution as the receiver.
  */
-- (FBLPromise *)onQueue:(dispatch_queue_t)queue always:(void (^)(void))work NS_REFINED_FOR_SWIFT;
+- (FBLPromise *)onQueue:(dispatch_queue_t)queue always:(FBLPromiseAlwaysWorkBlock)work
+    NS_REFINED_FOR_SWIFT;
 
 @end
 
@@ -41,10 +44,12 @@ NS_ASSUME_NONNULL_BEGIN
  */
 @interface FBLPromise<Value>(DotSyntax_AlwaysAdditions)
 
-- (FBLPromise* (^)(void (^)(void)))always FBL_PROMISES_DOT_SYNTAX NS_SWIFT_UNAVAILABLE("");
-- (FBLPromise* (^)(dispatch_queue_t, void (^)(void)))alwaysOn FBL_PROMISES_DOT_SYNTAX
+- (FBLPromise* (^)(FBLPromiseAlwaysWorkBlock))always FBL_PROMISES_DOT_SYNTAX
+    NS_SWIFT_UNAVAILABLE("");
+- (FBLPromise* (^)(dispatch_queue_t, FBLPromiseAlwaysWorkBlock))alwaysOn FBL_PROMISES_DOT_SYNTAX
     NS_SWIFT_UNAVAILABLE("");
 
 @end
 
 NS_ASSUME_NONNULL_END
+
diff --git a/Sources/FBLPromises/include/FBLPromise+Recover.h b/Sources/FBLPromises/include/FBLPromise+Recover.h
index 46aea69..c5be8b8 100644
--- a/Sources/FBLPromises/include/FBLPromise+Recover.h
+++ b/Sources/FBLPromises/include/FBLPromise+Recover.h
@@ -1,3 +1,8 @@
+
+
+
+
+
 /**
  Copyright 2018 Google Inc. All rights reserved.
 
@@ -20,6 +25,8 @@ NS_ASSUME_NONNULL_BEGIN
 
 @interface FBLPromise<Value>(RecoverAdditions)
 
+typedef id __nullable (^FBLPromiseRecoverWorkBlock)(NSError *error) NS_SWIFT_UNAVAILABLE("");
+
 /**
  Provides a new promise to recover in case the receiver gets rejected.
 
@@ -27,7 +34,7 @@ NS_ASSUME_NONNULL_BEGIN
  @return A new pending promise to use instead of the rejected one that gets resolved with resolution
          returned from `recovery` block.
  */
-- (FBLPromise *)recover:(nullable id (^)(NSError *))recovery NS_SWIFT_UNAVAILABLE("");
+- (FBLPromise *)recover:(FBLPromiseRecoverWorkBlock)recovery NS_SWIFT_UNAVAILABLE("");
 
 /**
  Provides a new promise to recover in case the receiver gets rejected.
@@ -38,7 +45,7 @@ NS_ASSUME_NONNULL_BEGIN
          returned from `recovery` block.
  */
 - (FBLPromise *)onQueue:(dispatch_queue_t)queue
-                recover:(nullable id (^)(NSError *))recovery NS_REFINED_FOR_SWIFT;
+                recover:(FBLPromiseRecoverWorkBlock)recovery NS_REFINED_FOR_SWIFT;
 
 @end
 
@@ -48,9 +55,9 @@ NS_ASSUME_NONNULL_BEGIN
  */
 @interface FBLPromise<Value>(DotSyntax_RecoverAdditions)
 
-- (FBLPromise * (^)(id __nullable (^)(NSError *)))recover FBL_PROMISES_DOT_SYNTAX
+- (FBLPromise * (^)(FBLPromiseRecoverWorkBlock))recover FBL_PROMISES_DOT_SYNTAX
     NS_SWIFT_UNAVAILABLE("");
-- (FBLPromise * (^)(dispatch_queue_t, id __nullable (^)(NSError *)))recoverOn
+- (FBLPromise * (^)(dispatch_queue_t, FBLPromiseRecoverWorkBlock))recoverOn
     FBL_PROMISES_DOT_SYNTAX NS_SWIFT_UNAVAILABLE("");
 
 @end
diff --git a/Sources/FBLPromises/include/FBLPromise+Validate.h b/Sources/FBLPromises/include/FBLPromise+Validate.h
index 0734a85..37f45d1 100644
--- a/Sources/FBLPromises/include/FBLPromise+Validate.h
+++ b/Sources/FBLPromises/include/FBLPromise+Validate.h
@@ -20,6 +20,8 @@ NS_ASSUME_NONNULL_BEGIN
 
 @interface FBLPromise<Value>(ValidateAdditions)
 
+typedef BOOL (^FBLPromiseValidateWorkBlock)(Value __nullable value) NS_SWIFT_UNAVAILABLE("");
+
 /**
  Validates a fulfilled value or rejects the value if it can not be validated.
 
@@ -27,7 +29,7 @@ NS_ASSUME_NONNULL_BEGIN
  @return A new pending promise that gets either resolved with same resolution as the receiver or
          rejected with `FBLPromiseErrorCodeValidationFailure` error code in `FBLPromiseErrorDomain`.
  */
-- (FBLPromise *)validate:(BOOL (^)(Value __nullable))predicate NS_SWIFT_UNAVAILABLE("");
+- (FBLPromise *)validate:(FBLPromiseValidateWorkBlock)predicate NS_SWIFT_UNAVAILABLE("");
 
 /**
  Validates a fulfilled value or rejects the value if it can not be validated.
@@ -38,7 +40,7 @@ NS_ASSUME_NONNULL_BEGIN
          rejected with `FBLPromiseErrorCodeValidationFailure` error code in `FBLPromiseErrorDomain`.
  */
 - (FBLPromise *)onQueue:(dispatch_queue_t)queue
-               validate:(BOOL (^)(Value __nullable))predicate NS_REFINED_FOR_SWIFT;
+               validate:(FBLPromiseValidateWorkBlock)predicate NS_REFINED_FOR_SWIFT;
 
 @end
 
@@ -48,9 +50,9 @@ NS_ASSUME_NONNULL_BEGIN
  */
 @interface FBLPromise<Value>(DotSyntax_ValidateAdditions)
 
-- (FBLPromise* (^)(BOOL (^)(Value __nullable)))validate FBL_PROMISES_DOT_SYNTAX
+- (FBLPromise* (^)(FBLPromiseValidateWorkBlock))validate FBL_PROMISES_DOT_SYNTAX
     NS_SWIFT_UNAVAILABLE("");
-- (FBLPromise* (^)(dispatch_queue_t, BOOL (^)(Value __nullable)))validateOn FBL_PROMISES_DOT_SYNTAX
+- (FBLPromise* (^)(dispatch_queue_t, FBLPromiseValidateWorkBlock))validateOn FBL_PROMISES_DOT_SYNTAX
     NS_SWIFT_UNAVAILABLE("");
 
 @end
diff --git a/Sources/FBLPromises/include/FBLPromise+Wrap.h b/Sources/FBLPromises/include/FBLPromise+Wrap.h
index ec52469..21b4325 100644
--- a/Sources/FBLPromises/include/FBLPromise+Wrap.h
+++ b/Sources/FBLPromises/include/FBLPromise+Wrap.h
@@ -23,7 +23,7 @@ NS_ASSUME_NONNULL_BEGIN
  */
 typedef void (^FBLPromiseCompletion)(void) NS_SWIFT_UNAVAILABLE("");
 typedef void (^FBLPromiseObjectCompletion)(id __nullable) NS_SWIFT_UNAVAILABLE("");
-typedef void (^FBLPromiseErrorCompletion)(NSError* __nullable error) NS_SWIFT_UNAVAILABLE("");
+typedef void (^FBLPromiseErrorCompletion)(NSError* __nullable) NS_SWIFT_UNAVAILABLE("");
 typedef void (^FBLPromiseObjectOrErrorCompletion)(id __nullable, NSError* __nullable)
     NS_SWIFT_UNAVAILABLE("");
 typedef void (^FBLPromiseErrorOrObjectCompletion)(NSError* __nullable, id __nullable)
diff --git a/Sources/Promises/Promise+All.swift b/Sources/Promises/Promise+All.swift
index e817fff..07cd292 100644
--- a/Sources/Promises/Promise+All.swift
+++ b/Sources/Promises/Promise+All.swift
@@ -40,7 +40,7 @@ public func all<Value>(
 public func all<Value, Container: Sequence>(
   on queue: DispatchQueue = .promises,
   _ promises: Container
-) -> Promise<[Value]> where Container.Iterator.Element == Promise<Value> {
+) -> Promise<[Value]> where Container.Element == Promise<Value> {
   let promises = promises.map { $0.objCPromise }
   let promise = Promise<[Value]>(
     Promise<[Value]>.ObjCPromise<AnyObject>.__onQueue(queue, all: promises)
diff --git a/Sources/Promises/Promise+When.swift b/Sources/Promises/Promise+When.swift
index 630241a..3d9e77b 100644
--- a/Sources/Promises/Promise+When.swift
+++ b/Sources/Promises/Promise+When.swift
@@ -46,7 +46,7 @@ public func when<Value>(
 public func when<Value, Container: Sequence>(
   on queue: DispatchQueue = .promises,
   _ promises: Container
-) -> Promise<[When<Value>]> where Container.Iterator.Element == Promise<Value> {
+) -> Promise<[When<Value>]> where Container.Element == Promise<Value> {
   let promises = promises.map { $0.objCPromise }
   let promise = Promise<[When<Value>]>(
     Promise<[When<Value>]>.ObjCPromise<AnyObject>.__onQueue(