 // MARK: - Lift
 
 public func lift<A, B: Equatable, E>(valueTransformer: ValueTransformer<A, B, E>, defaultTransformedValue: @autoclosure () -> B) -> ValueTransformer<A?, B, E> {
-    let transformValue: A? -> Result<B, E> = { a in
-        if let a = a {
-            return valueTransformer.transformedValue(a)
+    let transformValue: A? -> Result<B, E> = { value in
+        if let value = value {
+            return valueTransformer.transformedValue(value)
         } else {
             return success(defaultTransformedValue())
         }
     }
 
-    let reverseTransformValue: B -> Result<A?, E> = { b in
-        if b == defaultTransformedValue() {
+    let reverseTransformValue: B -> Result<A?, E> = { value in
+        if value == defaultTransformedValue() {
             return success(nil)
         } else {
-            return valueTransformer.reverseTransformedValue(b).map { $0 }
+            return valueTransformer.reverseTransformedValue(value).map { $0 }
         }
     }
 

}

public func lift<A, B, E>(valueTransformer: ValueTransformer<A, B, E>) -> ValueTransformer<[A], [B], E> {
    let transformValue: [A] -> Result<[B], E> = { xs in
        var result = [B]()
        for x in xs {
            switch valueTransformer.transformedValue(x) {
            case .Success(let value):
                result.append(value.unbox)
            case .Failure(let error):

        return success(result)
    }

    let reverseTransformValue: [B] -> Result<[A], E> = { values in
        var result = [A]()
        for element in values {
            switch valueTransformer.reverseTransformedValue(element) {
            case .Success(let value):
                result.append(value.unbox)
            case .Failure(let error):
