anchor.diff:                              | x when x.StartsWith("if") -> 
                                           match (List.ofSeq x.[3..]) with
                                                       //| Comparison(c,[]) -> IFSTART(c)
  -                                                    | Comparison(c,[]) -> IFSTART(c) // boolean expression like if x
  +                                                    | BoolExpr(c,[]) -> IFSTART(c) // boolean expression like if x
                                                       | _ as x -> failwithf "ERROR: parsing if expression, unparseable expression encountered %A" x
                                           //IFSTART(c)
                               | _ as x -> UNKNOWNLOGIC(x)
  
positive.code:     and (|ComparisonExpr|_|) = function // series of or statements
          | ComparisonFactor(e1, Ws(t)) ->
              let rec aux e1 = function
                | 'o'::'r'::Ws(Expr(e2, t)) -> aux (OR(e1,e2)) t
                | _ as t -> Some(e1,t)
              aux e1 t
          | _ -> None
      and (|ComparisonFactor|_|) = function
          | Expr(e1,Ws(t)) ->
              let rec aux e = function
                  | 'a'::'n'::'d'::Ws(ComparisonFactor(e2,t)) -> aux (AND(e1,e2)) t
                  | t -> Some(e,t)
              aux e1 t
          | _ -> None
  
      and (|Expr|_|) = function
          | Factor(e1, Ws(t)) ->
              let rec aux e1 = function
                | 'o'::'r'::Ws(Expr(e2, t)) -> aux (OR(e1,e2)) t
                | '!'::'='::Ws(Factor(e2,t)) -> aux(NOTEQUAL(e1,e2)) t
                | '='::'='::Ws(Factor(e2,t)) -> aux (EQUALS(e1,e2)) t
                | '+'::Ws(Factor(e2, t)) -> aux (ADD(e1,e2)) t
                | '-'::Ws(Factor(e2, t)) -> aux (SUB(e1,e2)) t
                | '<'::Ws(Expr(e2,t)) -> aux(LESSTHAN(e1,e2)) t
                | '>'::Ws(Expr(e2,t)) -> aux(GREATERTHAN(e1,e2)) t
                | t -> Some(e1, t)
              aux e1 t
          | _ -> None
        and (|Factor|_|) = function
  
negative.code:                     | FCONST(i1) -> FCONST(-i1)
                      | _ as x -> failwithf "Error: evaluating expression, negation performed on inappropriate types %A" x
              | BOOLEXP(e) -> match (c e) with
                              | BConstOrVar vf (r) -> BCONST(r)
                              | _ as x -> failwithf "Error: evaluating bool expression, %A not a boolean const"  x
  
              | NOT(e) -> match (c e) with
                              | BConstOrVar vf (b) -> BCONST(not b)
                              | _ as x -> failwithf "Error: evaluating expression, not performed on inappropriate types %A" x
              | AND(e1,e2) -> match (c e1),(c e2) with
                              | BConstOrVar vf (b1),BConstOrVar vf (b2) -> BCONST(b1&&b2)
                              | _ as x -> failwithf "Error: evaluating AND expression, not performed on inappropriate types %A" x
              | OR(e1,e2) -> match (c e1),(c e2) with
                              | BConstOrVar vf (b1),BConstOrVar vf (b2) -> BCONST(b1||b2)
                              | _ as x -> failwithf "Error: evaluating OR expression, not performed on inappropriate types %A" x
              | VARIABLE(v) -> vf.Get(v) // TODO - implement dot notation
              | BCONST(_) as x -> x // Nothing to calculate here
  