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

// 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)
        } else {
            return success(defaultTransformedValue())
        }
    }

    let reverseTransformValue: B -> Result<A?, E> = { b in
        if b == defaultTransformedValue() {
            return success(nil)
        } else {
            return valueTransformer.reverseTransformedValue(b).map { $0 }
        }
    }


        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):
