anchor.diff:          | _ -> 
               Block (a |> List.map (fun (var, value) -> VarDeclaration (env.NewVar var, match value with Some v -> trE v | None -> Undefined)))
       | S.While (a, b) -> While (trE a, trS b)
  -    | S.With (a, b) -> failwith "TODO"
  +    | S.With (a, b) -> failwith "Unsupported: JS with statement"
       | S.StatementComment _ -> failwith "impossible, comments are not parsed"
   
   let createInline thisArg args isPure inlineString =        
  
positive.code:         | SB.``<<``     -> Binary(trE a, BinaryOperator.``<<``, trE c)
          | SB.``<<=``    -> mbin a MutatingBinaryOperator.``<<=`` c
          | SB.``<=``     -> Binary(trE a, BinaryOperator.``<=``, trE c)
          | SB.``=``      ->
              match trE a with
              | ItemGet (d, e)
              | ItemGetNonPure (d, e) -> ItemSet(d, e, trE c)
              | Var d -> checkNotMutating (Var d) (fun _ -> VarSet(d, trE c))
              | a -> failwith "invalid form at '='"
          | SB.``==``     -> Binary(trE a, BinaryOperator.``==``, trE c)
          | SB.``===``    -> Binary(trE a, BinaryOperator.``===``, trE c)
          | SB.``>``      -> Binary(trE a, BinaryOperator.``>``, trE c)
  
negative.code:         this.Inputs |> List.contains expr
  
  exception RecognitionError
  
  let checkNotMutating (env: Environment) a f =
      if env.IsInput a then
          failwith "arguments of inlined functions should not be mutated"
      else f a
  
  let setValue (env: Environment) expr value =
      match expr with
      | ItemGet (d, e)
      | ItemGetNonPure (d, e) -> ItemSet(d, e, value)
      | Var d -> checkNotMutating env (Var d) (fun _ -> VarSet(d, value))
      | _ -> failwith "invalid form for setter"
  
  let rec transformExpression (env: Environment) (expr: S.Expression) =
      let inline trE e = transformExpression env e
  