 public enum Result<T>: EitherType {
 	// MARK: Constructors
 
+	/// Constructs a success from a `value`.
+	public static func success(value: T) -> Result {
+		return Success(Box(value))
+	}
+
 	/// Constructs a failure from an `error`.
 	public static func failure(error: NSError) -> Result {
 		return Failure(error)
 	}
 
-	/// Constructs a success from a `value`.
-	public static func success(value: T) -> Result {
-		return Success(Box(value))
-	}
-
 
 	// MARK: Deconstruction
+
+	/// Returns the value from `Success` Results, `nil` otherwise.
+	public var success: T? {
+		return analysis(
+			ifSuccess: id,
+			ifFailure: const(nil))
+	}
 
 	/// Returns the error from `Failure` Results, `nil` otherwise.
 	public var failure: NSError? {
 		return analysis(
-			ifFailure: id,
-			ifSuccess: const(nil))
-	}
-
-	/// Returns the value from `Success` Results, `nil` otherwise.
-	public var success: T? {
-		return analysis(
-			ifFailure: const(nil),
-			ifSuccess: id)
+			ifSuccess: const(nil),
+			ifFailure: id)
 	}
 
 	/// Case analysis for Result.
 	///
 	/// Returns the value produced by applying `ifFailure` to `Failure` Results, or `ifSuccess` to `Success` Results.
-	public func analysis<Result>(#ifFailure: NSError -> Result, ifSuccess: T -> Result) -> Result {
+	public func analysis<Result>(#ifSuccess: T -> Result, ifFailure: NSError -> Result) -> Result {
 		switch self {
 		case let Failure(error):
 			return ifFailure(error)


	// MARK: Cases

	case Failure(NSError)
	case Success(Box<T>)


	// MARK: EitherType


	public func either<Result>(ifLeft: NSError -> Result, _ ifRight: T -> Result) -> Result {
		return analysis(
			ifSuccess: ifRight,
			ifFailure: ifLeft)
	}
}

