anchor.diff:              if hashSet.Add(v) then
                   temp.[i] <- v
                   i <- i + 1
  -        temp.[0..i ]
  -
  +        temp.[0..i]
  +
  +    /// pass an array byref to reverse it in place
  +    let revInPlace (arr: 'a[] byref ) =
  +        checkNonNull "array" arr
  +        let arrlen, revlen = arr.Length-1, arr.Length/2 - 1
  +        for idx in 0 .. revlen do
  +            let t1 = arr.[idx] 
  +            let t2 = arr.[arrlen-idx]
  +            arr.[idx] <- t2
  +            arr.[arrlen-idx] <- t1
  +
  +
  +    /// Return an array of elements that preceded the first element that failed
  +    /// to satisfy the predicate
  +    let takeWhile predicate (array: 'T[]) = 
  +        checkNonNull "array" array
  +        if array.Length = 0 then Array.empty else
  +        let mutable count = 0
  +        while count < array.Length && predicate array.[count] do
  +            count <- count + 1
  +        array.[0..count]
   
   
   [<RequireQualifiedAccess>]
  
positive.code:         match str with
          | null -> null
          | str ->
              match str.ToCharArray() |> Array.toList with
              | [] -> str
              | h :: t when Char.IsUpper h -> String (Char.ToLower h :: t |> List.toArray)
              | _ -> str
  
      let extractTrailingIndex (str: string) =
  
negative.code:                | "" -> str, None
                 | index -> str.Substring (0, str.Length - index.Length), Some (int index)
  
      /// Remove all trailing and leading whitespace from the string
      /// return null if the string is null
      let trim (value: string) = match value with null -> null | x -> x.Trim()
      
      let split options (separator: string[]) (value: string) = 
  