anchor.diff:          try
               Ok (f x)
           with e -> Error e
  +
  +    /// Gets the 'Ok' value. If it's an 'Error' this function will throw an exception.
  +    let get (source: Result<'T,'Error>) = match source with Ok x -> x | _ -> invalidArg "source" "Result value was Error"
  +    let defaultValue value source = match source with Ok v -> v | _ -> value
  +    let defaultWith f source = match source with Ok v -> v | e -> f e
  +
  +    /// Converts a Result<'T,'U> to a Choice<'T,'U>.
  +    let toChoice (source: Result<'T,'U>) = match source with Ok x-> Choice1Of2 x | Error x -> Choice2Of2 x
  +
  +    /// Creates a Result<'T,'U> from a Choice<'T,'U>.
  +    let ofChoice (source: Choice<'T,'U>) = match source with Choice1Of2 x-> Ok x | Choice2Of2 x -> Error x
  +    
  +    /// <summary>
  +    /// Creates two lists by classifying the values depending on whether they were wrapped with Ok or Error.
  +    /// </summary>
  +    /// <returns>
  +    /// A tuple with both resulting lists, Oks are in the first list.
  +    /// </returns>
  +    let partition (source: list<Result<'T,'Error>>) =
  +        let rec loop ((acc1, acc2) as acc) = function
  +            | [] -> acc
  +            | x::xs ->
  +                match x with
  +                | Ok x -> loop (x::acc1, acc2) xs
  +                | Error x -> loop (acc1, x::acc2) xs
  +        loop ([], []) (List.rev source)
   
   
   /// Additional operations on Choice
  
positive.code:         with _ -> None
  
  
  /// Additional operations on Result<'Ok,'Error>
  [<RequireQualifiedAccess>]
  module Result =
      let result x = Ok x
  
negative.code:         if index = -1 then None else Some index
      #endif
  
      /// <summary>
      /// Creates two lists by applying the mapper function to each element in the list
      /// and classifying the transformed values depending on whether they were wrapped with Choice1Of2 or Choice2Of2.
      /// </summary>
      /// <returns>
      /// A tuple with both resulting lists.
      /// </returns>
      let partitionMap (mapper: 'T -> Choice<'T1,'T2>) (source: list<'T>) =
          let rec loop ((acc1, acc2) as acc) = function
              | [] -> acc
              | x::xs ->
                  match mapper x with
                  | Choice1Of2 x -> loop (x::acc1, acc2) xs
                  | Choice2Of2 x -> loop (acc1, x::acc2) xs
          loop ([], []) (List.rev source)
  
  
  /// Additional operations on Array
  [<RequireQualifiedAccess>]
  