anchor.diff:              | (false, _) -> Err "Non-existent term."
           | Fun fn ->
               fn terms
  +        | Subqueries subqueries ->
  +            Terms (List.map (Subquery.eval terms) subqueries)
   
       static member evalMany (terms : Map<string, Term>) (subqueries : Subquery seq) =
           let mutable result = true
  
positive.code:             if ty = typeof<int> then Val (I (value :?> int))
              elif ty = typeof<single> then Val (F (value :?> single))
              else failwith "Unsupported value type."
          | Patterns.Let (var, q, q2) -> 
              Let (var.Name, Subquery.unquote q, Subquery.unquote q2)
          | Patterns.IfThenElse (predicate, consequent, alternative) ->
              If (Subquery.unquote predicate, Subquery.unquote consequent, Subquery.unquote alternative)
          | Patterns.Call (_, info, args) ->
              match (info.Name, args) with
              | ("at", [arg; arg2]) -> At (Subquery.unquote arg, Subquery.unquote arg2)
              | ("head", [arg]) -> Head (Subquery.unquote arg)
              | ("tail", [arg]) -> Tail (Subquery.unquote arg)
              | ("not", [arg]) -> Not (Subquery.unquote arg)
              | ("op_Equality", [arg; arg2]) -> Eq (Subquery.unquote arg, Subquery.unquote arg2)
              | ("op_LessThan", [arg; arg2]) -> Lt (Subquery.unquote arg, Subquery.unquote arg2)
              | ("op_LessThanOrEqual", [arg; arg2]) -> Le (Subquery.unquote arg, Subquery.unquote arg2)
  
negative.code:             | B b -> if b then Subquery.eval terms consequent else Subquery.eval terms alternate
              | Err _ as err -> err
              | _ -> Err "Invalid If predicate; B required."
          | Intersects (subquery, subquery2) ->
              match (Subquery.eval terms subquery, Subquery.eval terms subquery2) with
              | (Box3 box, Box3 box2) -> B (box.Intersects box2)
              | (V3 v, Box3 box) | (Box3 box, V3 v)-> B (box.Intersects v)
              | ((Err _ as err), _) -> err
              | (_, (Err _ as err)) -> err
              | (_, _) -> Err "Invalid Intersect arguments."
          | Or (subquery, subquery2) ->
              match (Subquery.eval terms subquery, Subquery.eval terms subquery2) with
              | (B b, B b2) -> B (b || b2)
              | ((Err _ as err), _) -> err
              | (_, (Err _ as err)) -> err
              | (_, _) -> Err "Invalid Or arguments; two B's required."
          | And (subquery, subquery2) ->
              match (Subquery.eval terms subquery, Subquery.eval terms subquery2) with
              | (B b, B b2) -> B (b && b2)
              | ((Err _ as err), _) -> err
              | (_, (Err _ as err)) -> err
              | (_, _) -> Err "Invalid And arguments; two B's required."
          | Not subquery ->
              match Subquery.eval terms subquery with
              | B b -> B (not b)
              | Err _ as err -> err
              | _ -> Err "Invalid Not argument; B required."
          | Val term ->
              term
          | Var varName ->
  