anchor.diff:  (* ------------------------------------------------------------------------- *)
   
   /// Read file and convert content into a list of strings.
  +// OPTIMIZE : Use a StreamReader here instead of the OCaml-compatibility stuff.
   let strings_of_file filename = 
       let fd = 
  -        try 
  +        try
               Pervasives.open_in filename
           with
  -        | Sys_error _ -> failwith("strings_of_file: can't open " + filename)
  +        | Sys_error _ ->
  +            failwith("strings_of_file: can't open " + filename)
       let rec suck_lines acc = 
           try 
               let l = Pervasives.input_line fd
  
positive.code: open FSharp.Compatibility.OCaml.Num
  #endif
  
  (* ------------------------------------------------------------------------- *)
  (* A few missing functions to convert OCaml code to F#.                      *)
  (* ------------------------------------------------------------------------- *)
  
  let inline tuple x = (x, x)
  
  // Follow the naming convention of ExtCore
  [<RequireQualifiedAccess>]
  module Choice =
      /// Applies the specified binding function to a choice value representing an error value
      /// (Choice2Of2). If the choice value represents a result value (Choice1Of2), the result value
      /// is passed through without modification.
      let bindError (binding : 'Error -> Choice<'T, 'Failure>) value =
          match value with
          | Choice1Of2 result -> Choice1Of2 result
          | Choice2Of2 error -> binding error
  
      /// Applies the specified binding function to a choice value representing a pair of result values
      /// (Choice1Of2). If one of choice values represents an error value (Choice2Of2), the error value
      /// is passed through without modification.
      let bind2 (binding : 'T -> 'U -> Choice<'V, 'Error>) value1 value2 =
          match value1, value2 with
          | Choice1Of2 result1, Choice1Of2 result2 -> binding result1 result2
          | Choice1Of2 _, Choice2Of2 error
          | Choice2Of2 error, _ -> Choice2Of2 error
  
      let rec tryFind f xs = 
          match xs with
          | [] -> Choice2Of2 <| Exception "tryfind"
          | h :: t -> 
              match f h with
              | Choice1Of2 result -> Choice1Of2 result
              | Choice2Of2 _ -> tryFind f t
  
      let tuple (x, y) =
          (Choice1Of2 x, Choice1Of2 y)
  
      let succeed x =
          Choice1Of2 x
  
      let failwith s =
          Choice2Of2 <| Exception s
  
      let fail() =
          failwith ""
  
      let inline failwithDouble s =
          (failwith s, failwith s)
  
      /// If Choice is 1Of2, return its value; otherwise, throw ArgumentException.
      let get = function
          | Choice1Of2 a -> a
          | Choice2Of2 e -> invalidArg "choice" (sprintf "The choice value was Choice2Of2 '%A'" e)
  
  // TODO : Move this into FSharp.Compatibility.OCaml
  module Ratio =
      open FSharp.Compatibility.OCaml
      open FSharp.Compatibility.OCaml.Num
  
      // NOTE : not sure what kind of normalization should be done here
      let normalize_ratio x = x
      let numerator_ratio(r : Ratio.ratio) = r.Numerator
      let denominator_ratio(r : Ratio.ratio) = r.Denominator
  
  let inline (==) (x : 'T) (y : 'T) =
      System.Object.ReferenceEquals(x, y)
  
  // The exception fired by failwith is used as a control flow.
  // KeyNotFoundException is not recognized in many cases, so we have to use redefine Failure for compatibility.
  
negative.code:      data)
  
  /// Read file and convert content into a string.
  // OPTIMIZE : Use a StringBuilder and iterate over the file to avoid creating
  // intermediate values all at once when we can stream them instead.
  // Initialize the StringBuilder's capacity to the file size to avoid re-allocation.
  let string_of_file filename = end_itlist (fun s t -> s + "\n" + t) (strings_of_file filename)
  
  /// Write out a string to a named file.
  // OPTIMIZE : Make this an alias for System.IO.File.WriteAllText().
  let file_of_string filename s = 
      let fd = Pervasives.open_out filename
      output_string fd s
  