anchor.diff:          | Patterns.Value (value, ty) ->
               if ty = typeof<int> then Val (I (value :?> int))
               elif ty = typeof<single> then Val (F (value :?> single))
  -            else failwith "Unsupported value type."
  -        | Patterns.NewArray (_, items) ->
  -            Subqueries (List.map Subquery.unquote items)
  +            elif ty = typeof<Map<string, Term> -> Term> then Fun (value :?> (Map<string, Term> -> Term))
  +            else failwith "Unsupported Val or Fun 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.Lambda (var, body) ->
  -        //    match body. with
  -        //    | Patterns.
  -        //    Fun (var, )
  +        | Patterns.PropertyGet (_, info, args) ->
  +            match (info.Name, args) with
  +            | ("v3Zero", []) -> Val (V3 v3Zero)
  +            | ("v3One", []) -> Val (V3 v3One)
  +            | ("box3Zero", []) -> Val (Box3 (box3 v3Zero v3Zero))
  +            | ("box3One", []) -> Val (Box3 (box3 v3Zero v3One))
  +            | _ -> failwith "Unsupported call."
  +        | Patterns.NewTuple args ->
  +            match args with
  +            | [arg; arg2] -> PairCtor (Subquery.unquote arg, Subquery.unquote arg2)
  +            | _ -> failwith "Invalid Pair arguments; 2 Terms required (only 2-tuples are supported)."
  +        | Patterns.NewArray (_, items) ->
  +            Subqueries (List.map Subquery.unquote items)
           | Patterns.Call (_, info, args) ->
               match (info.Name, args) with
  +            | ("tagged", [arg]) -> Tagged (Subquery.unquote arg)
  +            | ("fst", [arg]) -> Fst (Subquery.unquote arg)
  +            | ("snd", [arg]) -> Snd (Subquery.unquote arg)
               | ("at", [arg; arg2]) -> At (Subquery.unquote arg, Subquery.unquote arg2)
  -            | ("GetArray", [arg2; arg]) -> At (Subquery.unquote arg, Subquery.unquote arg2)
  +            | ("GetArray", [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)
  +            | ("v3", [arg; arg2; arg3]) -> V3Ctor (Subquery.unquote arg, Subquery.unquote arg2, Subquery.unquote arg3)
  +            | ("box3", [arg; arg2]) -> Box3Ctor (Subquery.unquote arg, Subquery.unquote arg2)
               | ("intersects", [arg; arg2]) -> Intersects (Subquery.unquote arg, Subquery.unquote arg2)
               | ("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)
               | ("op_GreaterThan", [arg; arg2]) -> Gt (Subquery.unquote arg, Subquery.unquote arg2)
               | ("op_GreaterThanOrEqual", [arg; arg2]) -> Ge (Subquery.unquote arg, Subquery.unquote arg2)
  +            | ("isType", [arg]) ->
  +                match (arg, info.GetGenericArguments ()) with
  +                | (Patterns.Value (:? string as varName, _),  [|ty|]) -> ByType (varName, ty)
  +                | (_, _) -> failwith "Invalid IsType arguments."
               | _ -> failwith "Unsupported call."
           | _ -> failwith "Unsupport Subquery expression."
   
  
positive.code: 
      do
          for compName in compNames do
              subqueries.Add (Is (Var (Constants.Ecs.IntraComponentPrefix + compName)))
  
      member inline private this.IndexStore<'c when 'c : struct and 'c :> 'c Component> compName archetypeId (stores : Dictionary<string, Store>) =
          match stores.TryGetValue compName with
  
negative.code:         match (term, term2) with
          | (I i, I i2) -> B (i > i2)
          | (F f, F f2) -> B (f > f2)
          | (S s, S s2) -> B (s > s2)
          | (Cmp c, Cmp c2) -> B (c.CompareTo c2 > 0)
          | (Terms terms, Terms terms2) ->
              if terms.Length = terms2.Length then
  