anchor.diff:      /// Sequences two functions like Haskell ($).
       let inline (^) f g = f g
   
  -    /// Test for equality, usually faster than (=).
  -    let inline (==) (x : 'a) (y : 'a) = fastEq x y
  -
  -    /// Test just the value parts of a type for equality. Reflective and slow.
  -    let inline (===) (x : 'a) (y : 'a) = similar x y
  -
  +/// An option type that doesn't generate garbage.
  +/// TODO: document.
  +type FOption<'a> =
  +    struct
  +        val private Exists : bool
  +        val private ValueOpt : 'a
  +        private new (_ : unit) = { Exists = false; ValueOpt = Unchecked.defaultof<'a> }
  +        private new (_ : unit, value : 'a) = { Exists = true; ValueOpt = value }
  +        static member Some (value : 'a) = new FOption<'a> ((), value)
  +        static member None () = new FOption<'a> (())
  +        static member FromOpt (opt : 'a option) = match opt with Option.Some value -> FOption.Some value | None -> FOption.None ()
  +        static member ToOpt (fopt : FOption<'a>) = if fopt.Exists then Some fopt.ValueOpt else None
  +        member this.IsSome = this.Exists
  +        member this.IsNone = not this.Exists
  +        member this.Value = if this.Exists then this.ValueOpt else failwith "FOption has no value to get."
  +        member this.Map (fn : 'a -> 'b) = if this.Exists then new FOption<'b> ((), fn this.ValueOpt) else new FOption<'b> (())
  +        end
  +
  +[<RequireQualifiedAccess>]
  +module FOption =
  +
  +    let fromOpt opt = FOption.FromOpt opt
  +    let toOpt fopt = FOption.ToOpt fopt
  +    let some value = FOption.Some value
  +    let none () = FOption.None ()
  +    let isSome (fopt : FOption<'a>) = fopt.IsSome
  +    let isNone (fopt : FOption<'a>) = fopt.IsNone
  +    let get (fopt : FOption<'a>) = fopt.Value
  +    let map fn (fopt : FOption<'a>) = fopt.Map fn
   
   [<AutoOpen>]
   module HMapModule =
  
positive.code:                     arr.[idx] <- add hkv earr (dep + 1) entry
                      Multiple arr
      
                  | Bucket _ ->
      
                      // logically should never hit here
                      failwithumf ()
  
negative.code:                 
                  // handle clash cases
                  match node with
                  | Nil -> Gutter (Array.singleton hkv)
                  | Singleton hkv' -> Gutter [|hkv'; hkv|]
                  | Multiple _ -> failwithumf () // should never hit here
                  | Gutter gutter -> Gutter (addToGutter hkv gutter)
      
          let rec remove (h : int) (k : 'k) (dep : int) (node : HNode<'k, 'v>) : HNode<'k, 'v> =
              match node with
  