anchor.diff:  /// Contains functions and a compuation expression build for Railway-oriented programming.
  -module Chessie.Rop
  +module Chessie.Attempt
   
   open System
   
   /// Railway-oriented programming result - represents the result of a computation
  -type RopResult<'TSuccess, 'TMessage> =    
  +type AttemptResult<'TSuccess, 'TMessage> =    
       /// Represents the result of a successful computation
       | Success of 'TSuccess * 'TMessage list
       /// Represents the result of a failed computation
  
positive.code:     either fSuccess fFailure result
  
  /// If the result is a Success it executes the given function on the value. Otherwise the exisiting failure is propagated.
  /// Infix version of Rop.bind
  let inline (>>=) result f = bind f result
  
  /// If the wrapped function is a success and the given result is a success the function is applied on the value. Otherwise the exisiting error messages are propagated.
  
negative.code:         | Failure(m1), Failure(m2) -> Failure(m1 @ m2)) (succeed []) xs
      |> lift List.rev
  
  /// Converts an option into a AttemptResult.
  let inline failIfNone message result =
      match result with
      | Some x -> succeed x
      | None -> fail message
  
  /// Builder type for railway-oriented computation expressions.
  type AttemptBuilder() =
      member __.Zero() = succeed ()
      member __.Bind(m, f) = bind f m
      member __.Return(x) = succeed x
      member __.ReturnFrom(x) = x
  
  /// Railway-oriented computation expressions.
  let attempt = AttemptBuilder()
  