anchor.diff:                      | FCONST(i1) -> FCONST(-i1)
                       | _ as x -> failwithf "Error: evaluating expression, negation performed on inappropriate types %A" x
               | BOOLEXP(e) -> match (c e) with
  -                            | BCONST(_) -> e
  +                            | BConstOrVar vf (r) -> BCONST(r)
                               | _ as x -> failwithf "Error: evaluating bool expression, %A not a boolean const"  x
   
               | NOT(e) -> match (c e) with
  -                            | BCONST(b) -> BCONST(not b)
  +                            | 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
  -                            | BCONST(b1),BCONST(b2) -> BCONST(b1&&b2)
  +                            | 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
  -                            | BCONST(b1),BCONST(b2) -> BCONST(b1||b2)
  +                            | 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
  
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:         member x.Get(v) = match lookupLocals locals  v with // match locals.TryFind(v) with 
                              | None -> ve.Get(v) 
                              | Some(s) -> s
      /// Match either a  Bool const or variable that's a bool
      let (|BConstOrVar|_|) (vf:VarFetcher) = function
          | BCONST(c) -> Some(c)
          | VARIABLE(v) ->
              match vf.Get(v) with
                  | BCONST(e) ->
                      Some(e)
                  | _ as x -> failwithf "ERROR: '%A' not a boolean expression" (x.ToString())
          | _ -> None
  
      /// Main template rendering class.  Instantiated usings
      /// string as a constructor and optionally a function to fetch sub templates  
  