anchor.diff:      | true -> Some u
       | _ -> None
   
  -  let noneIfEmpty =
  +  let private noneIfEmpty =
       function
       | [] -> None
       | x :: xs -> Some(x :: xs)
  
positive.code:     |> Seq.toList
      |> noneIfEmpty
  
    let (|FunctionalProperty|_|) p (R(_, xs)) =
      xs
      |> Seq.filter (fun ((P p'), _) -> p = p')
      |> Seq.map (fun (_, o) -> o)
      |> Seq.toList
      |> (function
      | x :: xs -> Some x
      | _ -> None)
  
    let (|DataProperty|_|) p f r =
      match r with
      | Property p xo -> Some(mapO f xo)
      | _ -> None
  
    let (|FunctionalDataProperty|_|) p f r =
      match r with
        | FunctionalProperty p (O(o, _)) -> Some(f o)
        | _ -> None
  
    let (|Traverse|_|) p r =
      match r with
      | Property p xo -> traverse xo |> noneIfEmpty
      | _ -> None
  
    let (|TraverseFunctional|_|) p r =
      match r with
      | Property p xo -> traverse xo |> ( function | x :: xs -> Some x | _ -> None )
      | _ -> None
  
    let (|HasType|_|) t (R(_, xs)) =
      xs
      |> Seq.filter
           (fun ((P p), (O(Uri o, _))) ->
           p = Uri.from (prefixes.rdf + "type") && t = o)
      |> Seq.map (fun (_, (O(Uri o, _))) -> o)
      |> Seq.toList
      |> noneIfEmpty
  
  module xsd =
    open VDS.RDF
  
negative.code: 
    let mapObject f (O(o, _)) = f o
    let mapO f = List.map (mapObject f)
    let resourceId (R(S s, _)) = s
  
    let traverse xo =
      [ for (O(_, next)) in xo do
  