nits on comments and structure

Author: cbaker6

Sources/ParseSwift/Types/ParseError.swift

@@ -408,70 +408,72 @@ extension ParseError: CustomStringConvertible {
 }
 
 // MARK: Compare Errors
-extension Error {
+public extension Error {
+
     /**
-     Validates if the given ParseError Code is equal to the error.
+     Returns the respective `ParseError` if the given `ParseError` code is equal to the error.
 
     **Example use case:**
     ~~~
-    if error.equalsTo(.objectNotFound)  {
-        //Do stuff
+    if let parseError = error.equalsTo(.objectNotFound)  {
+        print(parseError.description)
     }
     ~~~
      - parameter errorCode: A `ParseError` code to compare to.
 
-     - returns: A boolean indicating wheter or not the `Error` is the `errorCode`
+     - returns: Returns the `ParseError` with respect to the `Error`. If the error is not a `ParseError`, returns nil.
      */
-    public func equalsTo(_ errorCode: ParseError.Code) -> Bool {
-        guard let error = self as? ParseError else {
-            return false
+    func equalsTo(_ errorCode: ParseError.Code) -> ParseError? {
+        guard let error = self as? ParseError,
+                error.code == errorCode else {
+            return nil
         }
-        return error.code == errorCode
+        return error
     }
 
     /**
-     Returns an optional ParseError if the given ParseError Code is equal to the error.
+     Validates if the given `ParseError` code is equal to the error.
 
     **Example use case:**
     ~~~
-    if let parseError = error.equalsTo(.objectNotFound)  {
-        print(parseError.description)
+    if error.equalsTo(.objectNotFound)  {
+        //Do stuff
     }
     ~~~
      - parameter errorCode: A `ParseError` code to compare to.
 
-     - returns: An optional `ParseError`
+     - returns: A boolean indicating whether or not the `Error` is the `errorCode`.
      */
-    public func equalsTo(_ errorCode: ParseError.Code) -> ParseError? {
-        guard let error = self as? ParseError,
-                error.code == errorCode else {
-            return nil
+    func equalsTo(_ errorCode: ParseError.Code) -> Bool {
+        guard equalsTo(errorCode) != nil else {
+            return false
         }
-        return error
+        return true
     }
 
     /**
-     Validates if the given ParseError Codes contains the error.
+     Returns the respective `ParseError` if the `Error` is contained in the array of `ParseError` codes.
 
     **Example use case:**
     ~~~
-    if error.containedIn(.objectNotFound, .invalidQuery)  {
-        //Do stuff
+    if let parseError = error.containedIn([.objectNotFound, .invalidQuery])  {
+        print(parseError.description)
     }
     ~~~
-     - parameter errorCodes: A variadic amount of zero or more of `ParseError` codes to compare to.
+     - parameter errorCodes: An array of zero or more of `ParseError` codes to compare to.
 
-     - returns: A boolean indicating wheter or not the `Error` is contained in the `errorCodes`
+     - returns: Returns the `ParseError` with respect to the `Error`. If the error is not a `ParseError`, returns nil.
      */
-    public func containedIn(_ errorCodes: ParseError.Code...) -> Bool {
-        guard let error = self as? ParseError else {
-            return false
+    func containedIn(_ errorCodes: [ParseError.Code]) -> ParseError? {
+        guard let error = self as? ParseError,
+              errorCodes.contains(error.code) == true else {
+            return nil
         }
-        return errorCodes.contains(error.code)
+        return error
     }
 
     /**
-     Returns an optional ParseError if the given ParseError Codes contains the error.
+     Returns the respective `ParseError` if the `Error` is contained in the list of `ParseError` codes.
 
     **Example use case:**
     ~~~
@@ -481,18 +483,14 @@ extension Error {
     ~~~
      - parameter errorCodes: A variadic amount of zero or more of `ParseError` codes to compare to.
 
-     - returns: An optional `ParseError`
+     - returns: Returns the `ParseError` with respect to the `Error`. If the error is not a `ParseError`, returns nil.
      */
-    public func containedIn(_ errorCodes: ParseError.Code...) -> ParseError? {
-        guard let error = self as? ParseError,
-                errorCodes.contains(error.code) == true else {
-            return nil
-        }
-        return error
+    func containedIn(_ errorCodes: ParseError.Code...) -> ParseError? {
+        containedIn(errorCodes)
     }
 
     /**
-     Validates if the given ParseError Codes contains the error.
+     Validates if the given `ParseError` codes contains the error.
 
     **Example use case:**
     ~~~
@@ -502,33 +500,29 @@ extension Error {
     ~~~
      - parameter errorCodes: An array of zero or more of `ParseError` codes to compare to.
 
-     - returns: A boolean indicating wheter or not the `Error` is contained in the `errorCodes`
+     - returns: A boolean indicating whether or not the `Error` is contained in the `errorCodes`.
      */
-    public func containedIn(_ errorCodes: [ParseError.Code]) -> Bool {
-        guard let error = self as? ParseError else {
+    func containedIn(_ errorCodes: [ParseError.Code]) -> Bool {
+        guard containedIn(errorCodes) != nil else {
             return false
         }
-        return errorCodes.contains(error.code)
+        return true
     }
 
     /**
-     Returns an optional ParseError if the given ParseError Codes contains the error.
+     Validates if the given `ParseError` codes contains the error.
 
     **Example use case:**
     ~~~
-    if let parseError = error.containedIn([.objectNotFound, .invalidQuery])  {
-        print(parseError.description)
+    if error.containedIn(.objectNotFound, .invalidQuery)  {
+        //Do stuff
     }
     ~~~
-     - parameter errorCodes: An array of zero or more of `ParseError` codes to compare to.
+     - parameter errorCodes: A variadic amount of zero or more of `ParseError` codes to compare to.
 
-     - returns: An optional `ParseError`
+     - returns: A boolean indicating whether or not the `Error` is contained in the `errorCodes`.
      */
-    public func containedIn(_ errorCodes: [ParseError.Code]) -> ParseError? {
-        guard let error = self as? ParseError,
-                errorCodes.contains(error.code) == true else {
-            return nil
-        }
-        return error
+    func containedIn(_ errorCodes: ParseError.Code...) -> Bool {
+        containedIn(errorCodes)
     }
 }