anchor.diff:          match strategy with
           | None | Some ReturnUnit -> Statement.expr(pyExpr)
           // TODO: Where to put these int wrappings? Add them also for function arguments?
  -        | Some Return ->  Statement.return'(wrapIntExpression t pyExpr)
  +        | Some Return ->  Statement.return'(pyExpr)
           | Some(Assign left) -> Statement.expr(assign None left pyExpr)
           | Some(Target left) -> Statement.expr(assign None (left |> Expression.identifier) pyExpr)
   
  
positive.code: 
      let transformSet (com: IPythonCompiler) ctx range fableExpr (value: Fable.Expr) kind =
          let expr, stmts = com.TransformAsExpr(ctx, fableExpr)
          let value', stmts' = com.TransformAsExpr(ctx, value)
          let value = value' |> wrapIntExpression value.Type
          let ret, stmts'' =
              match kind with
              | Fable.ValueSet -> expr, stmts @ stmts'
  
negative.code:         | Fable.IfThenElse(_,thenExpr,elseExpr,_) ->
              preferStatement || isPyStatement ctx false thenExpr || isPyStatement ctx false elseExpr
  
      let addErrorAndReturnNull (com: Compiler) (range: SourceLocation option) (error: string) =
          addError com [] range error
          Expression.name (Python.Identifier("None"))
  
      let ident (com: IPythonCompiler) (ctx: Context) (id: Fable.Ident) =
          com.GetIdentifier(ctx, id.Name)
  
      let identAsExpr (com: IPythonCompiler) (ctx: Context) (id: Fable.Ident) =
          com.GetIdentifierAsExpr(ctx, id.Name)
  
      let thisExpr =
          Expression.name("self")
  
      let ofInt (i: int) =
          Expression.constant(float i)
  