anchor.diff:      delegate of 'c byref * 'c2 byref * 'c3 byref * 'c4 byref * 'c5 byref * 'c6 byref * 'c7 byref * 'c8 byref * 'c9 byref * 's -> 's
   
   and [<StructuralEquality; NoComparison>] Term =
  -    | Err of string
  +    | Error of string
       | Tag
       | Bool of bool
       | Int of int
  
positive.code:                 if b then
                      match Subquery.eq termSnd termSnd2 with
                      | Bool _ as b -> b
                      | Err _ as err -> err
                      | _ -> failwithumf ()
                  else Bool false
              | Err _ as err -> err
              | _ -> failwithumf ()
          | (Terms terms, Terms terms2) ->
              if terms.Length = terms2.Length then
                  let mutable errOpt = ValueNone
                  let result = List.forall2 (fun term term2 -> match Subquery.eq term term2 with Bool b -> b | Err err -> (errOpt <- ValueSome err; false) | _ -> false) terms terms2
                  match errOpt with ValueSome err -> Err err | ValueNone -> Bool result
              else Bool false
          | ((Err _ as err), _) -> err
          | (_, (Err _ as err)) -> err
          | _ -> Err "Checking equality on unlike terms."
  
      static member gt term term2 =
          match (term, term2) with
  
negative.code: open Prime
  open Nu
  
  /// Allows a value to always pass as equal with another of its same type.
  /// TODO: move this elsewhere?
  type [<CustomEquality; NoComparison; Struct>] 'a AlwaysEqual =
      | AlwaysEqual of 'a
      member this.Value = match this with AlwaysEqual value -> value
      override this.GetHashCode () = 0
      override this.Equals (that : obj) = that :? AlwaysEqual<'a>
  
  /// The base component type of an Ecs.
  type Component<'c when 'c : struct and 'c :> 'c Component> =
      interface
          abstract Active : bool with get, set
          end
  
  /// The component that holds an entity's id.
  type [<NoEquality; NoComparison; Struct>] EntityId =
  