 precedence 100
 }
 
-public func >>- <V, U>(v: Result<V>, f: V -> Result<U>) -> Result<U> {
-    return v.flatMap(f)
+public func >>- <V, U>(result: Result<V>, transform: V -> Result<U>) -> Result<U> {
+    return result.flatMap(transform)
 }
 
 infix operator -<< {

precedence 130
}

public func <*> <V, U>(f: Result<V -> U>, v: Result<V>) -> Result<U> {
    return v.apply(f)
}

infix operator >>- {

        }
    }

    public func apply<U>(transform: Result<V -> U>) -> Result<U> {
        switch self {
        case .Error(let error):
            return .Error(error)
        case .Value(let value):
            switch transform {
            case .Error(let error):
                return .Error(error)
            case .Value(let transform):
