anchor.diff:  
       /// Pattern to match an expression, including equality and inequality
       /// Two tiered to capture and / or precedence.  Cascades into general expressions lower down
  -    let rec (|Comparison|_|) = function
  -        | 'n'::'o'::'t'::Ws(Comparison(e,rem)) -> Some(NOT(e),rem)
  +    let rec (|BoolExpr|_|) = function
  +        | 'n'::'o'::'t'::Ws(BoolExpr(e,rem)) -> Some(NOT(e),rem)
           | 'n'::'o'::'t'::Ws(ComparisonFactor(e,rem)) -> Some(NOT(e),rem)
  -        | '('::Comparison(e,[')']) -> Some(e,[]) // parenthetic comparator  e.g. not (a=6)
  +        | '('::BoolExpr(e,[')']) -> Some(e,[]) // parenthetic comparator  e.g. not (a=6)
           | ComparisonExpr(e1,Ws(rem)) ->
               match rem with
                   | '='::'='::Ws(ComparisonExpr(e2,rem)) -> Some(EQUALS(e1,e2),rem)
  
positive.code:                             | x when x.StartsWith("if") -> 
                                          match (List.ofSeq x.[3..]) with
                                                      //| Comparison(c,[]) -> IFSTART(c)
                                                      | Comparison(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)
  
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
  