anchor.diff:                      "The file to load (omit, or supply -, for standard input).")>]
             input : string option }
   
  -    let _emptyOpts = {
  +    let _emptyOpts : Options = {
           raw             = false;
           backendOpts     = None;
           stage           = None;
  
positive.code: ///     name is downcased.  The optimisation name 'all' is special, as it
  ///     force-enables (or force-disables) all optimisations.
  /// </returns>
  let parseOptionString (str : string) =
      str.ToLower()
          .Split([| "," ; ";" |],
                 System.StringSplitOptions.RemoveEmptyEntries)
  
negative.code:        | _ -> None
  
  /// Reverses a 2-argument function.
  let flip (f : 'A -> 'B -> 'C) (x : 'B) (y : 'A) : 'C = f y x
  
  /// Reverses a pair.
  let flipPair (x : 'A1, y : 'A2) : 'A2 * 'A1 = (y, x)
  
  /// A predicate that always returns true.
  let always (_ : _) : bool = true
  
  /// Applies f and g to x and returns (f x, g x).
  let splitThrough (f : 'A -> 'B) (g : 'A -> 'C) (x : 'A) : 'B * 'C =
      (f x, g x)
  
  /// Given f and x, returns (x, f x).
  let inAndOut (f : 'A -> 'B) : 'A -> 'A * 'B = splitThrough id f
  
  /// Given f and (x, y), returns (x, f x y).
  let inAndOut2 (f : 'A -> 'B -> 'C) (x : 'A, y : 'B) : 'A * 'C =
      (x, f x y)
  
  /// Passes fst through f, and snd through g.
  let pairMap (f : 'A1 -> 'B1) (g : 'A2 -> 'B2) : 'A1 * 'A2 -> 'B1 * 'B2 =
      splitThrough (fst >> f) (snd >> g)
  
  /// Converts a pairwise function to a function of two arguments.
  let curry (f : 'A * 'B -> 'C) (a : 'A) (b : 'B) : 'C = f (a, b)
  
  /// Converts a triple-wise function to a function of three arguments.
  let curry3 (f : 'A * 'B * 'C -> 'D) (a : 'A) (b : 'B) (c : 'C) : 'D =
      f (a, b, c)
  
  /// Converts a function of two arguments to a pairwise function.
  let uncurry (f : 'A -> 'B -> 'C) (a : 'A, b : 'B) : 'C = f a b
  
  /// Constructs a pair from left to right.
  let mkPair (a : 'A) (b : 'B) : 'A * 'B = (a, b)
  
  /// List cons (::) as a two-argument function.
  let cons (x : 'X) (xs : 'X list) : 'X list = x :: xs
  
  /// Puts a onto the top of a sequence b.
  let scons (x : 'X) : 'X seq -> 'X seq = Seq.append (Seq.singleton x)
  
  /// Returns `a` if the input is `Some a`, or `d` otherwise.
  let withDefault (d : 'A) : 'A option -> 'A =
      function
      | Some a -> a
      | None -> d
  
  /// Maps a function f through a set, and concatenates the resulting
  /// list of lists into one set.
  let unionMap (f : 'A -> Set<'B>) : Set<'A> -> Set<'B> =
      Set.toSeq
      >> Seq.map f
      >> Set.unionMany
  
  /// Maps a function f through a list, and concatenates the resulting
  /// list of lists into one list.
  let concatMap (f : 'A -> 'B list) (xs : 'A list) : 'B list =
      (* Adapted from the GHC base implementation,
       * see http://hackage.haskell.org/package/base-4.8.1.0/docs/src/Data.Foldable.html
       * for source and copyright information.
  